qemu-thread: delete unused functions
[qemu/mdroth.git] / qemu-img.c
blob7e3cc4cbd5cc57086703227a4121af11db722e48
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 "qemu-error.h"
27 #include "osdep.h"
28 #include "sysemu.h"
29 #include "block_int.h"
30 #include <stdio.h>
32 #ifdef _WIN32
33 #include <windows.h>
34 #endif
36 typedef struct img_cmd_t {
37 const char *name;
38 int (*handler)(int argc, char **argv);
39 } img_cmd_t;
41 /* Default to cache=writeback as data integrity is not important for qemu-tcg. */
42 #define BDRV_O_FLAGS BDRV_O_CACHE_WB
44 static void format_print(void *opaque, const char *name)
46 printf(" %s", name);
49 /* Please keep in synch with qemu-img.texi */
50 static void help(void)
52 const char *help_msg =
53 "qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n"
54 "usage: qemu-img command [command options]\n"
55 "QEMU disk image utility\n"
56 "\n"
57 "Command syntax:\n"
58 #define DEF(option, callback, arg_string) \
59 " " arg_string "\n"
60 #include "qemu-img-cmds.h"
61 #undef DEF
62 #undef GEN_DOCS
63 "\n"
64 "Command parameters:\n"
65 " 'filename' is a disk image filename\n"
66 " 'fmt' is the disk image format. It is guessed automatically in most cases\n"
67 " 'size' is the disk image size in bytes. Optional suffixes\n"
68 " 'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n"
69 " and T (terabyte, 1024G) are supported. 'b' is ignored.\n"
70 " 'output_filename' is the destination disk image filename\n"
71 " 'output_fmt' is the destination format\n"
72 " 'options' is a comma separated list of format specific options in a\n"
73 " name=value format. Use -o ? for an overview of the options supported by the\n"
74 " used format\n"
75 " '-c' indicates that target image must be compressed (qcow format only)\n"
76 " '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
77 " match exactly. The image doesn't need a working backing file before\n"
78 " rebasing in this case (useful for renaming the backing file)\n"
79 " '-h' with or without a command shows this help and lists the supported formats\n"
80 "\n"
81 "Parameters to snapshot subcommand:\n"
82 " 'snapshot' is the name of the snapshot to create, apply or delete\n"
83 " '-a' applies a snapshot (revert disk to saved state)\n"
84 " '-c' creates a snapshot\n"
85 " '-d' deletes a snapshot\n"
86 " '-l' lists all snapshots in the given image\n";
88 printf("%s\nSupported formats:", help_msg);
89 bdrv_iterate_format(format_print, NULL);
90 printf("\n");
91 exit(1);
94 #if defined(WIN32)
95 /* XXX: put correct support for win32 */
96 static int read_password(char *buf, int buf_size)
98 int c, i;
99 printf("Password: ");
100 fflush(stdout);
101 i = 0;
102 for(;;) {
103 c = getchar();
104 if (c == '\n')
105 break;
106 if (i < (buf_size - 1))
107 buf[i++] = c;
109 buf[i] = '\0';
110 return 0;
113 #else
115 #include <termios.h>
117 static struct termios oldtty;
119 static void term_exit(void)
121 tcsetattr (0, TCSANOW, &oldtty);
124 static void term_init(void)
126 struct termios tty;
128 tcgetattr (0, &tty);
129 oldtty = tty;
131 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
132 |INLCR|IGNCR|ICRNL|IXON);
133 tty.c_oflag |= OPOST;
134 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
135 tty.c_cflag &= ~(CSIZE|PARENB);
136 tty.c_cflag |= CS8;
137 tty.c_cc[VMIN] = 1;
138 tty.c_cc[VTIME] = 0;
140 tcsetattr (0, TCSANOW, &tty);
142 atexit(term_exit);
145 static int read_password(char *buf, int buf_size)
147 uint8_t ch;
148 int i, ret;
150 printf("password: ");
151 fflush(stdout);
152 term_init();
153 i = 0;
154 for(;;) {
155 ret = read(0, &ch, 1);
156 if (ret == -1) {
157 if (errno == EAGAIN || errno == EINTR) {
158 continue;
159 } else {
160 ret = -1;
161 break;
163 } else if (ret == 0) {
164 ret = -1;
165 break;
166 } else {
167 if (ch == '\r') {
168 ret = 0;
169 break;
171 if (i < (buf_size - 1))
172 buf[i++] = ch;
175 term_exit();
176 buf[i] = '\0';
177 printf("\n");
178 return ret;
180 #endif
182 static int print_block_option_help(const char *filename, const char *fmt)
184 BlockDriver *drv, *proto_drv;
185 QEMUOptionParameter *create_options = NULL;
187 /* Find driver and parse its options */
188 drv = bdrv_find_format(fmt);
189 if (!drv) {
190 error_report("Unknown file format '%s'", fmt);
191 return 1;
194 proto_drv = bdrv_find_protocol(filename);
195 if (!proto_drv) {
196 error_report("Unknown protocol '%s'", filename);
197 return 1;
200 create_options = append_option_parameters(create_options,
201 drv->create_options);
202 create_options = append_option_parameters(create_options,
203 proto_drv->create_options);
204 print_option_help(create_options);
205 free_option_parameters(create_options);
206 return 0;
209 static BlockDriverState *bdrv_new_open(const char *filename,
210 const char *fmt,
211 int flags)
213 BlockDriverState *bs;
214 BlockDriver *drv;
215 char password[256];
216 int ret;
218 bs = bdrv_new("image");
220 if (fmt) {
221 drv = bdrv_find_format(fmt);
222 if (!drv) {
223 error_report("Unknown file format '%s'", fmt);
224 goto fail;
226 } else {
227 drv = NULL;
230 ret = bdrv_open(bs, filename, flags, drv);
231 if (ret < 0) {
232 error_report("Could not open '%s': %s", filename, strerror(-ret));
233 goto fail;
236 if (bdrv_is_encrypted(bs)) {
237 printf("Disk image '%s' is encrypted.\n", filename);
238 if (read_password(password, sizeof(password)) < 0) {
239 error_report("No password given");
240 goto fail;
242 if (bdrv_set_key(bs, password) < 0) {
243 error_report("invalid password");
244 goto fail;
247 return bs;
248 fail:
249 if (bs) {
250 bdrv_delete(bs);
252 return NULL;
255 static int add_old_style_options(const char *fmt, QEMUOptionParameter *list,
256 const char *base_filename,
257 const char *base_fmt)
259 if (base_filename) {
260 if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) {
261 error_report("Backing file not supported for file format '%s'",
262 fmt);
263 return -1;
266 if (base_fmt) {
267 if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) {
268 error_report("Backing file format not supported for file "
269 "format '%s'", fmt);
270 return -1;
273 return 0;
276 static int img_create(int argc, char **argv)
278 int c, ret = 0;
279 uint64_t img_size = -1;
280 const char *fmt = "raw";
281 const char *base_fmt = NULL;
282 const char *filename;
283 const char *base_filename = NULL;
284 char *options = NULL;
286 for(;;) {
287 c = getopt(argc, argv, "F:b:f:he6o:");
288 if (c == -1) {
289 break;
291 switch(c) {
292 case '?':
293 case 'h':
294 help();
295 break;
296 case 'F':
297 base_fmt = optarg;
298 break;
299 case 'b':
300 base_filename = optarg;
301 break;
302 case 'f':
303 fmt = optarg;
304 break;
305 case 'e':
306 error_report("qemu-img: option -e is deprecated, please use \'-o "
307 "encryption\' instead!");
308 return 1;
309 case '6':
310 error_report("qemu-img: option -6 is deprecated, please use \'-o "
311 "compat6\' instead!");
312 return 1;
313 case 'o':
314 options = optarg;
315 break;
319 /* Get the filename */
320 if (optind >= argc) {
321 help();
323 filename = argv[optind++];
325 /* Get image size, if specified */
326 if (optind < argc) {
327 int64_t sval;
328 sval = strtosz_suffix(argv[optind++], NULL, STRTOSZ_DEFSUFFIX_B);
329 if (sval < 0) {
330 error_report("Invalid image size specified! You may use k, M, G or "
331 "T suffixes for ");
332 error_report("kilobytes, megabytes, gigabytes and terabytes.");
333 ret = -1;
334 goto out;
336 img_size = (uint64_t)sval;
339 if (options && !strcmp(options, "?")) {
340 ret = print_block_option_help(filename, fmt);
341 goto out;
344 ret = bdrv_img_create(filename, fmt, base_filename, base_fmt,
345 options, img_size, BDRV_O_FLAGS);
346 out:
347 if (ret) {
348 return 1;
350 return 0;
354 * Checks an image for consistency. Exit codes:
356 * 0 - Check completed, image is good
357 * 1 - Check not completed because of internal errors
358 * 2 - Check completed, image is corrupted
359 * 3 - Check completed, image has leaked clusters, but is good otherwise
361 static int img_check(int argc, char **argv)
363 int c, ret;
364 const char *filename, *fmt;
365 BlockDriverState *bs;
366 BdrvCheckResult result;
368 fmt = NULL;
369 for(;;) {
370 c = getopt(argc, argv, "f:h");
371 if (c == -1) {
372 break;
374 switch(c) {
375 case '?':
376 case 'h':
377 help();
378 break;
379 case 'f':
380 fmt = optarg;
381 break;
384 if (optind >= argc) {
385 help();
387 filename = argv[optind++];
389 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS);
390 if (!bs) {
391 return 1;
393 ret = bdrv_check(bs, &result);
395 if (ret == -ENOTSUP) {
396 error_report("This image format does not support checks");
397 bdrv_delete(bs);
398 return 1;
401 if (!(result.corruptions || result.leaks || result.check_errors)) {
402 printf("No errors were found on the image.\n");
403 } else {
404 if (result.corruptions) {
405 printf("\n%d errors were found on the image.\n"
406 "Data may be corrupted, or further writes to the image "
407 "may corrupt it.\n",
408 result.corruptions);
411 if (result.leaks) {
412 printf("\n%d leaked clusters were found on the image.\n"
413 "This means waste of disk space, but no harm to data.\n",
414 result.leaks);
417 if (result.check_errors) {
418 printf("\n%d internal errors have occurred during the check.\n",
419 result.check_errors);
423 bdrv_delete(bs);
425 if (ret < 0 || result.check_errors) {
426 printf("\nAn error has occurred during the check: %s\n"
427 "The check is not complete and may have missed error.\n",
428 strerror(-ret));
429 return 1;
432 if (result.corruptions) {
433 return 2;
434 } else if (result.leaks) {
435 return 3;
436 } else {
437 return 0;
441 static int img_commit(int argc, char **argv)
443 int c, ret;
444 const char *filename, *fmt;
445 BlockDriverState *bs;
447 fmt = NULL;
448 for(;;) {
449 c = getopt(argc, argv, "f:h");
450 if (c == -1) {
451 break;
453 switch(c) {
454 case '?':
455 case 'h':
456 help();
457 break;
458 case 'f':
459 fmt = optarg;
460 break;
463 if (optind >= argc) {
464 help();
466 filename = argv[optind++];
468 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR);
469 if (!bs) {
470 return 1;
472 ret = bdrv_commit(bs);
473 switch(ret) {
474 case 0:
475 printf("Image committed.\n");
476 break;
477 case -ENOENT:
478 error_report("No disk inserted");
479 break;
480 case -EACCES:
481 error_report("Image is read-only");
482 break;
483 case -ENOTSUP:
484 error_report("Image is already committed");
485 break;
486 default:
487 error_report("Error while committing image");
488 break;
491 bdrv_delete(bs);
492 if (ret) {
493 return 1;
495 return 0;
498 static int is_not_zero(const uint8_t *sector, int len)
500 int i;
501 len >>= 2;
502 for(i = 0;i < len; i++) {
503 if (((uint32_t *)sector)[i] != 0)
504 return 1;
506 return 0;
510 * Returns true iff the first sector pointed to by 'buf' contains at least
511 * a non-NUL byte.
513 * 'pnum' is set to the number of sectors (including and immediately following
514 * the first one) that are known to be in the same allocated/unallocated state.
516 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
518 int v, i;
520 if (n <= 0) {
521 *pnum = 0;
522 return 0;
524 v = is_not_zero(buf, 512);
525 for(i = 1; i < n; i++) {
526 buf += 512;
527 if (v != is_not_zero(buf, 512))
528 break;
530 *pnum = i;
531 return v;
535 * Compares two buffers sector by sector. Returns 0 if the first sector of both
536 * buffers matches, non-zero otherwise.
538 * pnum is set to the number of sectors (including and immediately following
539 * the first one) that are known to have the same comparison result
541 static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
542 int *pnum)
544 int res, i;
546 if (n <= 0) {
547 *pnum = 0;
548 return 0;
551 res = !!memcmp(buf1, buf2, 512);
552 for(i = 1; i < n; i++) {
553 buf1 += 512;
554 buf2 += 512;
556 if (!!memcmp(buf1, buf2, 512) != res) {
557 break;
561 *pnum = i;
562 return res;
565 #define IO_BUF_SIZE (2 * 1024 * 1024)
567 static int img_convert(int argc, char **argv)
569 int c, ret = 0, n, n1, bs_n, bs_i, compress, cluster_size, cluster_sectors;
570 const char *fmt, *out_fmt, *out_baseimg, *out_filename;
571 BlockDriver *drv, *proto_drv;
572 BlockDriverState **bs = NULL, *out_bs = NULL;
573 int64_t total_sectors, nb_sectors, sector_num, bs_offset;
574 uint64_t bs_sectors;
575 uint8_t * buf = NULL;
576 const uint8_t *buf1;
577 BlockDriverInfo bdi;
578 QEMUOptionParameter *param = NULL, *create_options = NULL;
579 QEMUOptionParameter *out_baseimg_param;
580 char *options = NULL;
581 const char *snapshot_name = NULL;
583 fmt = NULL;
584 out_fmt = "raw";
585 out_baseimg = NULL;
586 compress = 0;
587 for(;;) {
588 c = getopt(argc, argv, "f:O:B:s:hce6o:");
589 if (c == -1) {
590 break;
592 switch(c) {
593 case '?':
594 case 'h':
595 help();
596 break;
597 case 'f':
598 fmt = optarg;
599 break;
600 case 'O':
601 out_fmt = optarg;
602 break;
603 case 'B':
604 out_baseimg = optarg;
605 break;
606 case 'c':
607 compress = 1;
608 break;
609 case 'e':
610 error_report("qemu-img: option -e is deprecated, please use \'-o "
611 "encryption\' instead!");
612 return 1;
613 case '6':
614 error_report("qemu-img: option -6 is deprecated, please use \'-o "
615 "compat6\' instead!");
616 return 1;
617 case 'o':
618 options = optarg;
619 break;
620 case 's':
621 snapshot_name = optarg;
622 break;
626 bs_n = argc - optind - 1;
627 if (bs_n < 1) {
628 help();
631 out_filename = argv[argc - 1];
633 if (options && !strcmp(options, "?")) {
634 ret = print_block_option_help(out_filename, out_fmt);
635 goto out;
638 if (bs_n > 1 && out_baseimg) {
639 error_report("-B makes no sense when concatenating multiple input "
640 "images");
641 ret = -1;
642 goto out;
645 bs = qemu_mallocz(bs_n * sizeof(BlockDriverState *));
647 total_sectors = 0;
648 for (bs_i = 0; bs_i < bs_n; bs_i++) {
649 bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, BDRV_O_FLAGS);
650 if (!bs[bs_i]) {
651 error_report("Could not open '%s'", argv[optind + bs_i]);
652 ret = -1;
653 goto out;
655 bdrv_get_geometry(bs[bs_i], &bs_sectors);
656 total_sectors += bs_sectors;
659 if (snapshot_name != NULL) {
660 if (bs_n > 1) {
661 error_report("No support for concatenating multiple snapshot\n");
662 ret = -1;
663 goto out;
665 if (bdrv_snapshot_load_tmp(bs[0], snapshot_name) < 0) {
666 error_report("Failed to load snapshot\n");
667 ret = -1;
668 goto out;
672 /* Find driver and parse its options */
673 drv = bdrv_find_format(out_fmt);
674 if (!drv) {
675 error_report("Unknown file format '%s'", out_fmt);
676 ret = -1;
677 goto out;
680 proto_drv = bdrv_find_protocol(out_filename);
681 if (!proto_drv) {
682 error_report("Unknown protocol '%s'", out_filename);
683 ret = -1;
684 goto out;
687 create_options = append_option_parameters(create_options,
688 drv->create_options);
689 create_options = append_option_parameters(create_options,
690 proto_drv->create_options);
692 if (options) {
693 param = parse_option_parameters(options, create_options, param);
694 if (param == NULL) {
695 error_report("Invalid options for file format '%s'.", out_fmt);
696 ret = -1;
697 goto out;
699 } else {
700 param = parse_option_parameters("", create_options, param);
703 set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
704 ret = add_old_style_options(out_fmt, param, out_baseimg, NULL);
705 if (ret < 0) {
706 goto out;
709 /* Get backing file name if -o backing_file was used */
710 out_baseimg_param = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
711 if (out_baseimg_param) {
712 out_baseimg = out_baseimg_param->value.s;
715 /* Check if compression is supported */
716 if (compress) {
717 QEMUOptionParameter *encryption =
718 get_option_parameter(param, BLOCK_OPT_ENCRYPT);
720 if (!drv->bdrv_write_compressed) {
721 error_report("Compression not supported for this file format");
722 ret = -1;
723 goto out;
726 if (encryption && encryption->value.n) {
727 error_report("Compression and encryption not supported at "
728 "the same time");
729 ret = -1;
730 goto out;
734 /* Create the new image */
735 ret = bdrv_create(drv, out_filename, param);
736 if (ret < 0) {
737 if (ret == -ENOTSUP) {
738 error_report("Formatting not supported for file format '%s'",
739 out_fmt);
740 } else if (ret == -EFBIG) {
741 error_report("The image size is too large for file format '%s'",
742 out_fmt);
743 } else {
744 error_report("%s: error while converting %s: %s",
745 out_filename, out_fmt, strerror(-ret));
747 goto out;
750 out_bs = bdrv_new_open(out_filename, out_fmt,
751 BDRV_O_FLAGS | BDRV_O_RDWR | BDRV_O_NO_FLUSH);
752 if (!out_bs) {
753 ret = -1;
754 goto out;
757 bs_i = 0;
758 bs_offset = 0;
759 bdrv_get_geometry(bs[0], &bs_sectors);
760 buf = qemu_malloc(IO_BUF_SIZE);
762 if (compress) {
763 ret = bdrv_get_info(out_bs, &bdi);
764 if (ret < 0) {
765 error_report("could not get block driver info");
766 goto out;
768 cluster_size = bdi.cluster_size;
769 if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) {
770 error_report("invalid cluster size");
771 ret = -1;
772 goto out;
774 cluster_sectors = cluster_size >> 9;
775 sector_num = 0;
776 for(;;) {
777 int64_t bs_num;
778 int remainder;
779 uint8_t *buf2;
781 nb_sectors = total_sectors - sector_num;
782 if (nb_sectors <= 0)
783 break;
784 if (nb_sectors >= cluster_sectors)
785 n = cluster_sectors;
786 else
787 n = nb_sectors;
789 bs_num = sector_num - bs_offset;
790 assert (bs_num >= 0);
791 remainder = n;
792 buf2 = buf;
793 while (remainder > 0) {
794 int nlow;
795 while (bs_num == bs_sectors) {
796 bs_i++;
797 assert (bs_i < bs_n);
798 bs_offset += bs_sectors;
799 bdrv_get_geometry(bs[bs_i], &bs_sectors);
800 bs_num = 0;
801 /* printf("changing part: sector_num=%" PRId64 ", "
802 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
803 "\n", sector_num, bs_i, bs_offset, bs_sectors); */
805 assert (bs_num < bs_sectors);
807 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;
809 ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow);
810 if (ret < 0) {
811 error_report("error while reading");
812 goto out;
815 buf2 += nlow * 512;
816 bs_num += nlow;
818 remainder -= nlow;
820 assert (remainder == 0);
822 if (n < cluster_sectors) {
823 memset(buf + n * 512, 0, cluster_size - n * 512);
825 if (is_not_zero(buf, cluster_size)) {
826 ret = bdrv_write_compressed(out_bs, sector_num, buf,
827 cluster_sectors);
828 if (ret != 0) {
829 error_report("error while compressing sector %" PRId64,
830 sector_num);
831 goto out;
834 sector_num += n;
836 /* signal EOF to align */
837 bdrv_write_compressed(out_bs, 0, NULL, 0);
838 } else {
839 int has_zero_init = bdrv_has_zero_init(out_bs);
841 sector_num = 0; // total number of sectors converted so far
842 for(;;) {
843 nb_sectors = total_sectors - sector_num;
844 if (nb_sectors <= 0) {
845 break;
847 if (nb_sectors >= (IO_BUF_SIZE / 512)) {
848 n = (IO_BUF_SIZE / 512);
849 } else {
850 n = nb_sectors;
853 while (sector_num - bs_offset >= bs_sectors) {
854 bs_i ++;
855 assert (bs_i < bs_n);
856 bs_offset += bs_sectors;
857 bdrv_get_geometry(bs[bs_i], &bs_sectors);
858 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
859 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
860 sector_num, bs_i, bs_offset, bs_sectors); */
863 if (n > bs_offset + bs_sectors - sector_num) {
864 n = bs_offset + bs_sectors - sector_num;
867 if (has_zero_init) {
868 /* If the output image is being created as a copy on write image,
869 assume that sectors which are unallocated in the input image
870 are present in both the output's and input's base images (no
871 need to copy them). */
872 if (out_baseimg) {
873 if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
874 n, &n1)) {
875 sector_num += n1;
876 continue;
878 /* The next 'n1' sectors are allocated in the input image. Copy
879 only those as they may be followed by unallocated sectors. */
880 n = n1;
882 } else {
883 n1 = n;
886 ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
887 if (ret < 0) {
888 error_report("error while reading");
889 goto out;
891 /* NOTE: at the same time we convert, we do not write zero
892 sectors to have a chance to compress the image. Ideally, we
893 should add a specific call to have the info to go faster */
894 buf1 = buf;
895 while (n > 0) {
896 /* If the output image is being created as a copy on write image,
897 copy all sectors even the ones containing only NUL bytes,
898 because they may differ from the sectors in the base image.
900 If the output is to a host device, we also write out
901 sectors that are entirely 0, since whatever data was
902 already there is garbage, not 0s. */
903 if (!has_zero_init || out_baseimg ||
904 is_allocated_sectors(buf1, n, &n1)) {
905 ret = bdrv_write(out_bs, sector_num, buf1, n1);
906 if (ret < 0) {
907 error_report("error while writing");
908 goto out;
911 sector_num += n1;
912 n -= n1;
913 buf1 += n1 * 512;
917 out:
918 free_option_parameters(create_options);
919 free_option_parameters(param);
920 qemu_free(buf);
921 if (out_bs) {
922 bdrv_delete(out_bs);
924 if (bs) {
925 for (bs_i = 0; bs_i < bs_n; bs_i++) {
926 if (bs[bs_i]) {
927 bdrv_delete(bs[bs_i]);
930 qemu_free(bs);
932 if (ret) {
933 return 1;
935 return 0;
938 #ifdef _WIN32
939 static int64_t get_allocated_file_size(const char *filename)
941 typedef DWORD (WINAPI * get_compressed_t)(const char *filename, DWORD *high);
942 get_compressed_t get_compressed;
943 struct _stati64 st;
945 /* WinNT support GetCompressedFileSize to determine allocate size */
946 get_compressed = (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA");
947 if (get_compressed) {
948 DWORD high, low;
949 low = get_compressed(filename, &high);
950 if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR)
951 return (((int64_t) high) << 32) + low;
954 if (_stati64(filename, &st) < 0)
955 return -1;
956 return st.st_size;
958 #else
959 static int64_t get_allocated_file_size(const char *filename)
961 struct stat st;
962 if (stat(filename, &st) < 0)
963 return -1;
964 return (int64_t)st.st_blocks * 512;
966 #endif
968 static void dump_snapshots(BlockDriverState *bs)
970 QEMUSnapshotInfo *sn_tab, *sn;
971 int nb_sns, i;
972 char buf[256];
974 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
975 if (nb_sns <= 0)
976 return;
977 printf("Snapshot list:\n");
978 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
979 for(i = 0; i < nb_sns; i++) {
980 sn = &sn_tab[i];
981 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
983 qemu_free(sn_tab);
986 static int img_info(int argc, char **argv)
988 int c;
989 const char *filename, *fmt;
990 BlockDriverState *bs;
991 char fmt_name[128], size_buf[128], dsize_buf[128];
992 uint64_t total_sectors;
993 int64_t allocated_size;
994 char backing_filename[1024];
995 char backing_filename2[1024];
996 BlockDriverInfo bdi;
998 fmt = NULL;
999 for(;;) {
1000 c = getopt(argc, argv, "f:h");
1001 if (c == -1) {
1002 break;
1004 switch(c) {
1005 case '?':
1006 case 'h':
1007 help();
1008 break;
1009 case 'f':
1010 fmt = optarg;
1011 break;
1014 if (optind >= argc) {
1015 help();
1017 filename = argv[optind++];
1019 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING);
1020 if (!bs) {
1021 return 1;
1023 bdrv_get_format(bs, fmt_name, sizeof(fmt_name));
1024 bdrv_get_geometry(bs, &total_sectors);
1025 get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512);
1026 allocated_size = get_allocated_file_size(filename);
1027 if (allocated_size < 0) {
1028 snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
1029 } else {
1030 get_human_readable_size(dsize_buf, sizeof(dsize_buf),
1031 allocated_size);
1033 printf("image: %s\n"
1034 "file format: %s\n"
1035 "virtual size: %s (%" PRId64 " bytes)\n"
1036 "disk size: %s\n",
1037 filename, fmt_name, size_buf,
1038 (total_sectors * 512),
1039 dsize_buf);
1040 if (bdrv_is_encrypted(bs)) {
1041 printf("encrypted: yes\n");
1043 if (bdrv_get_info(bs, &bdi) >= 0) {
1044 if (bdi.cluster_size != 0) {
1045 printf("cluster_size: %d\n", bdi.cluster_size);
1048 bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
1049 if (backing_filename[0] != '\0') {
1050 path_combine(backing_filename2, sizeof(backing_filename2),
1051 filename, backing_filename);
1052 printf("backing file: %s (actual path: %s)\n",
1053 backing_filename,
1054 backing_filename2);
1056 dump_snapshots(bs);
1057 bdrv_delete(bs);
1058 return 0;
1061 #define SNAPSHOT_LIST 1
1062 #define SNAPSHOT_CREATE 2
1063 #define SNAPSHOT_APPLY 3
1064 #define SNAPSHOT_DELETE 4
1066 static int img_snapshot(int argc, char **argv)
1068 BlockDriverState *bs;
1069 QEMUSnapshotInfo sn;
1070 char *filename, *snapshot_name = NULL;
1071 int c, ret = 0, bdrv_oflags;
1072 int action = 0;
1073 qemu_timeval tv;
1075 bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
1076 /* Parse commandline parameters */
1077 for(;;) {
1078 c = getopt(argc, argv, "la:c:d:h");
1079 if (c == -1) {
1080 break;
1082 switch(c) {
1083 case '?':
1084 case 'h':
1085 help();
1086 return 0;
1087 case 'l':
1088 if (action) {
1089 help();
1090 return 0;
1092 action = SNAPSHOT_LIST;
1093 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
1094 break;
1095 case 'a':
1096 if (action) {
1097 help();
1098 return 0;
1100 action = SNAPSHOT_APPLY;
1101 snapshot_name = optarg;
1102 break;
1103 case 'c':
1104 if (action) {
1105 help();
1106 return 0;
1108 action = SNAPSHOT_CREATE;
1109 snapshot_name = optarg;
1110 break;
1111 case 'd':
1112 if (action) {
1113 help();
1114 return 0;
1116 action = SNAPSHOT_DELETE;
1117 snapshot_name = optarg;
1118 break;
1122 if (optind >= argc) {
1123 help();
1125 filename = argv[optind++];
1127 /* Open the image */
1128 bs = bdrv_new_open(filename, NULL, bdrv_oflags);
1129 if (!bs) {
1130 return 1;
1133 /* Perform the requested action */
1134 switch(action) {
1135 case SNAPSHOT_LIST:
1136 dump_snapshots(bs);
1137 break;
1139 case SNAPSHOT_CREATE:
1140 memset(&sn, 0, sizeof(sn));
1141 pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
1143 qemu_gettimeofday(&tv);
1144 sn.date_sec = tv.tv_sec;
1145 sn.date_nsec = tv.tv_usec * 1000;
1147 ret = bdrv_snapshot_create(bs, &sn);
1148 if (ret) {
1149 error_report("Could not create snapshot '%s': %d (%s)",
1150 snapshot_name, ret, strerror(-ret));
1152 break;
1154 case SNAPSHOT_APPLY:
1155 ret = bdrv_snapshot_goto(bs, snapshot_name);
1156 if (ret) {
1157 error_report("Could not apply snapshot '%s': %d (%s)",
1158 snapshot_name, ret, strerror(-ret));
1160 break;
1162 case SNAPSHOT_DELETE:
1163 ret = bdrv_snapshot_delete(bs, snapshot_name);
1164 if (ret) {
1165 error_report("Could not delete snapshot '%s': %d (%s)",
1166 snapshot_name, ret, strerror(-ret));
1168 break;
1171 /* Cleanup */
1172 bdrv_delete(bs);
1173 if (ret) {
1174 return 1;
1176 return 0;
1179 static int img_rebase(int argc, char **argv)
1181 BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
1182 BlockDriver *old_backing_drv, *new_backing_drv;
1183 char *filename;
1184 const char *fmt, *out_basefmt, *out_baseimg;
1185 int c, flags, ret;
1186 int unsafe = 0;
1188 /* Parse commandline parameters */
1189 fmt = NULL;
1190 out_baseimg = NULL;
1191 out_basefmt = NULL;
1193 for(;;) {
1194 c = getopt(argc, argv, "uhf:F:b:");
1195 if (c == -1) {
1196 break;
1198 switch(c) {
1199 case '?':
1200 case 'h':
1201 help();
1202 return 0;
1203 case 'f':
1204 fmt = optarg;
1205 break;
1206 case 'F':
1207 out_basefmt = optarg;
1208 break;
1209 case 'b':
1210 out_baseimg = optarg;
1211 break;
1212 case 'u':
1213 unsafe = 1;
1214 break;
1218 if ((optind >= argc) || !out_baseimg) {
1219 help();
1221 filename = argv[optind++];
1224 * Open the images.
1226 * Ignore the old backing file for unsafe rebase in case we want to correct
1227 * the reference to a renamed or moved backing file.
1229 flags = BDRV_O_FLAGS | BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
1230 bs = bdrv_new_open(filename, fmt, flags);
1231 if (!bs) {
1232 return 1;
1235 /* Find the right drivers for the backing files */
1236 old_backing_drv = NULL;
1237 new_backing_drv = NULL;
1239 if (!unsafe && bs->backing_format[0] != '\0') {
1240 old_backing_drv = bdrv_find_format(bs->backing_format);
1241 if (old_backing_drv == NULL) {
1242 error_report("Invalid format name: '%s'", bs->backing_format);
1243 ret = -1;
1244 goto out;
1248 if (out_basefmt != NULL) {
1249 new_backing_drv = bdrv_find_format(out_basefmt);
1250 if (new_backing_drv == NULL) {
1251 error_report("Invalid format name: '%s'", out_basefmt);
1252 ret = -1;
1253 goto out;
1257 /* For safe rebasing we need to compare old and new backing file */
1258 if (unsafe) {
1259 /* Make the compiler happy */
1260 bs_old_backing = NULL;
1261 bs_new_backing = NULL;
1262 } else {
1263 char backing_name[1024];
1265 bs_old_backing = bdrv_new("old_backing");
1266 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
1267 ret = bdrv_open(bs_old_backing, backing_name, BDRV_O_FLAGS,
1268 old_backing_drv);
1269 if (ret) {
1270 error_report("Could not open old backing file '%s'", backing_name);
1271 goto out;
1274 bs_new_backing = bdrv_new("new_backing");
1275 ret = bdrv_open(bs_new_backing, out_baseimg, BDRV_O_FLAGS,
1276 new_backing_drv);
1277 if (ret) {
1278 error_report("Could not open new backing file '%s'", out_baseimg);
1279 goto out;
1284 * Check each unallocated cluster in the COW file. If it is unallocated,
1285 * accesses go to the backing file. We must therefore compare this cluster
1286 * in the old and new backing file, and if they differ we need to copy it
1287 * from the old backing file into the COW file.
1289 * If qemu-img crashes during this step, no harm is done. The content of
1290 * the image is the same as the original one at any time.
1292 if (!unsafe) {
1293 uint64_t num_sectors;
1294 uint64_t sector;
1295 int n;
1296 uint8_t * buf_old;
1297 uint8_t * buf_new;
1299 buf_old = qemu_malloc(IO_BUF_SIZE);
1300 buf_new = qemu_malloc(IO_BUF_SIZE);
1302 bdrv_get_geometry(bs, &num_sectors);
1304 for (sector = 0; sector < num_sectors; sector += n) {
1306 /* How many sectors can we handle with the next read? */
1307 if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
1308 n = (IO_BUF_SIZE / 512);
1309 } else {
1310 n = num_sectors - sector;
1313 /* If the cluster is allocated, we don't need to take action */
1314 ret = bdrv_is_allocated(bs, sector, n, &n);
1315 if (ret) {
1316 continue;
1319 /* Read old and new backing file */
1320 ret = bdrv_read(bs_old_backing, sector, buf_old, n);
1321 if (ret < 0) {
1322 error_report("error while reading from old backing file");
1323 goto out;
1325 ret = bdrv_read(bs_new_backing, sector, buf_new, n);
1326 if (ret < 0) {
1327 error_report("error while reading from new backing file");
1328 goto out;
1331 /* If they differ, we need to write to the COW file */
1332 uint64_t written = 0;
1334 while (written < n) {
1335 int pnum;
1337 if (compare_sectors(buf_old + written * 512,
1338 buf_new + written * 512, n - written, &pnum))
1340 ret = bdrv_write(bs, sector + written,
1341 buf_old + written * 512, pnum);
1342 if (ret < 0) {
1343 error_report("Error while writing to COW image: %s",
1344 strerror(-ret));
1345 goto out;
1349 written += pnum;
1353 qemu_free(buf_old);
1354 qemu_free(buf_new);
1358 * Change the backing file. All clusters that are different from the old
1359 * backing file are overwritten in the COW file now, so the visible content
1360 * doesn't change when we switch the backing file.
1362 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
1363 if (ret == -ENOSPC) {
1364 error_report("Could not change the backing file to '%s': No "
1365 "space left in the file header", out_baseimg);
1366 } else if (ret < 0) {
1367 error_report("Could not change the backing file to '%s': %s",
1368 out_baseimg, strerror(-ret));
1372 * TODO At this point it is possible to check if any clusters that are
1373 * allocated in the COW file are the same in the backing file. If so, they
1374 * could be dropped from the COW file. Don't do this before switching the
1375 * backing file, in case of a crash this would lead to corruption.
1377 out:
1378 /* Cleanup */
1379 if (!unsafe) {
1380 bdrv_delete(bs_old_backing);
1381 bdrv_delete(bs_new_backing);
1384 bdrv_delete(bs);
1385 if (ret) {
1386 return 1;
1388 return 0;
1391 static int img_resize(int argc, char **argv)
1393 int c, ret, relative;
1394 const char *filename, *fmt, *size;
1395 int64_t n, total_size;
1396 BlockDriverState *bs = NULL;
1397 QEMUOptionParameter *param;
1398 QEMUOptionParameter resize_options[] = {
1400 .name = BLOCK_OPT_SIZE,
1401 .type = OPT_SIZE,
1402 .help = "Virtual disk size"
1404 { NULL }
1407 fmt = NULL;
1408 for(;;) {
1409 c = getopt(argc, argv, "f:h");
1410 if (c == -1) {
1411 break;
1413 switch(c) {
1414 case '?':
1415 case 'h':
1416 help();
1417 break;
1418 case 'f':
1419 fmt = optarg;
1420 break;
1423 if (optind + 1 >= argc) {
1424 help();
1426 filename = argv[optind++];
1427 size = argv[optind++];
1429 /* Choose grow, shrink, or absolute resize mode */
1430 switch (size[0]) {
1431 case '+':
1432 relative = 1;
1433 size++;
1434 break;
1435 case '-':
1436 relative = -1;
1437 size++;
1438 break;
1439 default:
1440 relative = 0;
1441 break;
1444 /* Parse size */
1445 param = parse_option_parameters("", resize_options, NULL);
1446 if (set_option_parameter(param, BLOCK_OPT_SIZE, size)) {
1447 /* Error message already printed when size parsing fails */
1448 ret = -1;
1449 goto out;
1451 n = get_option_parameter(param, BLOCK_OPT_SIZE)->value.n;
1452 free_option_parameters(param);
1454 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR);
1455 if (!bs) {
1456 ret = -1;
1457 goto out;
1460 if (relative) {
1461 total_size = bdrv_getlength(bs) + n * relative;
1462 } else {
1463 total_size = n;
1465 if (total_size <= 0) {
1466 error_report("New image size must be positive");
1467 ret = -1;
1468 goto out;
1471 ret = bdrv_truncate(bs, total_size);
1472 switch (ret) {
1473 case 0:
1474 printf("Image resized.\n");
1475 break;
1476 case -ENOTSUP:
1477 error_report("This image format does not support resize");
1478 break;
1479 case -EACCES:
1480 error_report("Image is read-only");
1481 break;
1482 default:
1483 error_report("Error resizing image (%d)", -ret);
1484 break;
1486 out:
1487 if (bs) {
1488 bdrv_delete(bs);
1490 if (ret) {
1491 return 1;
1493 return 0;
1496 static const img_cmd_t img_cmds[] = {
1497 #define DEF(option, callback, arg_string) \
1498 { option, callback },
1499 #include "qemu-img-cmds.h"
1500 #undef DEF
1501 #undef GEN_DOCS
1502 { NULL, NULL, },
1505 int main(int argc, char **argv)
1507 const img_cmd_t *cmd;
1508 const char *cmdname;
1510 error_set_progname(argv[0]);
1512 bdrv_init();
1513 if (argc < 2)
1514 help();
1515 cmdname = argv[1];
1516 argc--; argv++;
1518 /* find the command */
1519 for(cmd = img_cmds; cmd->name != NULL; cmd++) {
1520 if (!strcmp(cmdname, cmd->name)) {
1521 return cmd->handler(argc, argv);
1525 /* not found */
1526 help();
1527 return 0;