qemu_img: is_not_zero() optimization
[qemu.git] / qemu-img.c
1 /*
2 * QEMU disk image utility
3 *
4 * Copyright (c) 2003-2008 Fabrice Bellard
5 *
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:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
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.
23 */
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>
31
32 #ifdef _WIN32
33 #include <windows.h>
34 #endif
35
36 typedef struct img_cmd_t {
37 const char *name;
38 int (*handler)(int argc, char **argv);
39 } img_cmd_t;
40
41 /* Default to cache=writeback as data integrity is not important for qemu-tcg. */
42 #define BDRV_O_FLAGS BDRV_O_CACHE_WB
43
44 static void format_print(void *opaque, const char *name)
45 {
46 printf(" %s", name);
47 }
48
49 /* Please keep in synch with qemu-img.texi */
50 static void help(void)
51 {
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 " '-p' show progress of command (only certain commands)\n"
81 "\n"
82 "Parameters to snapshot subcommand:\n"
83 " 'snapshot' is the name of the snapshot to create, apply or delete\n"
84 " '-a' applies a snapshot (revert disk to saved state)\n"
85 " '-c' creates a snapshot\n"
86 " '-d' deletes a snapshot\n"
87 " '-l' lists all snapshots in the given image\n";
88
89 printf("%s\nSupported formats:", help_msg);
90 bdrv_iterate_format(format_print, NULL);
91 printf("\n");
92 exit(1);
93 }
94
95 #if defined(WIN32)
96 /* XXX: put correct support for win32 */
97 static int read_password(char *buf, int buf_size)
98 {
99 int c, i;
100 printf("Password: ");
101 fflush(stdout);
102 i = 0;
103 for(;;) {
104 c = getchar();
105 if (c == '\n')
106 break;
107 if (i < (buf_size - 1))
108 buf[i++] = c;
109 }
110 buf[i] = '\0';
111 return 0;
112 }
113
114 #else
115
116 #include <termios.h>
117
118 static struct termios oldtty;
119
120 static void term_exit(void)
121 {
122 tcsetattr (0, TCSANOW, &oldtty);
123 }
124
125 static void term_init(void)
126 {
127 struct termios tty;
128
129 tcgetattr (0, &tty);
130 oldtty = tty;
131
132 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
133 |INLCR|IGNCR|ICRNL|IXON);
134 tty.c_oflag |= OPOST;
135 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
136 tty.c_cflag &= ~(CSIZE|PARENB);
137 tty.c_cflag |= CS8;
138 tty.c_cc[VMIN] = 1;
139 tty.c_cc[VTIME] = 0;
140
141 tcsetattr (0, TCSANOW, &tty);
142
143 atexit(term_exit);
144 }
145
146 static int read_password(char *buf, int buf_size)
147 {
148 uint8_t ch;
149 int i, ret;
150
151 printf("password: ");
152 fflush(stdout);
153 term_init();
154 i = 0;
155 for(;;) {
156 ret = read(0, &ch, 1);
157 if (ret == -1) {
158 if (errno == EAGAIN || errno == EINTR) {
159 continue;
160 } else {
161 ret = -1;
162 break;
163 }
164 } else if (ret == 0) {
165 ret = -1;
166 break;
167 } else {
168 if (ch == '\r') {
169 ret = 0;
170 break;
171 }
172 if (i < (buf_size - 1))
173 buf[i++] = ch;
174 }
175 }
176 term_exit();
177 buf[i] = '\0';
178 printf("\n");
179 return ret;
180 }
181 #endif
182
183 static int print_block_option_help(const char *filename, const char *fmt)
184 {
185 BlockDriver *drv, *proto_drv;
186 QEMUOptionParameter *create_options = NULL;
187
188 /* Find driver and parse its options */
189 drv = bdrv_find_format(fmt);
190 if (!drv) {
191 error_report("Unknown file format '%s'", fmt);
192 return 1;
193 }
194
195 proto_drv = bdrv_find_protocol(filename);
196 if (!proto_drv) {
197 error_report("Unknown protocol '%s'", filename);
198 return 1;
199 }
200
201 create_options = append_option_parameters(create_options,
202 drv->create_options);
203 create_options = append_option_parameters(create_options,
204 proto_drv->create_options);
205 print_option_help(create_options);
206 free_option_parameters(create_options);
207 return 0;
208 }
209
210 static BlockDriverState *bdrv_new_open(const char *filename,
211 const char *fmt,
212 int flags)
213 {
214 BlockDriverState *bs;
215 BlockDriver *drv;
216 char password[256];
217 int ret;
218
219 bs = bdrv_new("image");
220
221 if (fmt) {
222 drv = bdrv_find_format(fmt);
223 if (!drv) {
224 error_report("Unknown file format '%s'", fmt);
225 goto fail;
226 }
227 } else {
228 drv = NULL;
229 }
230
231 ret = bdrv_open(bs, filename, flags, drv);
232 if (ret < 0) {
233 error_report("Could not open '%s': %s", filename, strerror(-ret));
234 goto fail;
235 }
236
237 if (bdrv_is_encrypted(bs)) {
238 printf("Disk image '%s' is encrypted.\n", filename);
239 if (read_password(password, sizeof(password)) < 0) {
240 error_report("No password given");
241 goto fail;
242 }
243 if (bdrv_set_key(bs, password) < 0) {
244 error_report("invalid password");
245 goto fail;
246 }
247 }
248 return bs;
249 fail:
250 if (bs) {
251 bdrv_delete(bs);
252 }
253 return NULL;
254 }
255
256 static int add_old_style_options(const char *fmt, QEMUOptionParameter *list,
257 const char *base_filename,
258 const char *base_fmt)
259 {
260 if (base_filename) {
261 if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) {
262 error_report("Backing file not supported for file format '%s'",
263 fmt);
264 return -1;
265 }
266 }
267 if (base_fmt) {
268 if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) {
269 error_report("Backing file format not supported for file "
270 "format '%s'", fmt);
271 return -1;
272 }
273 }
274 return 0;
275 }
276
277 static int img_create(int argc, char **argv)
278 {
279 int c, ret = 0;
280 uint64_t img_size = -1;
281 const char *fmt = "raw";
282 const char *base_fmt = NULL;
283 const char *filename;
284 const char *base_filename = NULL;
285 char *options = NULL;
286
287 for(;;) {
288 c = getopt(argc, argv, "F:b:f:he6o:");
289 if (c == -1) {
290 break;
291 }
292 switch(c) {
293 case '?':
294 case 'h':
295 help();
296 break;
297 case 'F':
298 base_fmt = optarg;
299 break;
300 case 'b':
301 base_filename = optarg;
302 break;
303 case 'f':
304 fmt = optarg;
305 break;
306 case 'e':
307 error_report("qemu-img: option -e is deprecated, please use \'-o "
308 "encryption\' instead!");
309 return 1;
310 case '6':
311 error_report("qemu-img: option -6 is deprecated, please use \'-o "
312 "compat6\' instead!");
313 return 1;
314 case 'o':
315 options = optarg;
316 break;
317 }
318 }
319
320 /* Get the filename */
321 if (optind >= argc) {
322 help();
323 }
324 filename = argv[optind++];
325
326 /* Get image size, if specified */
327 if (optind < argc) {
328 int64_t sval;
329 sval = strtosz_suffix(argv[optind++], NULL, STRTOSZ_DEFSUFFIX_B);
330 if (sval < 0) {
331 error_report("Invalid image size specified! You may use k, M, G or "
332 "T suffixes for ");
333 error_report("kilobytes, megabytes, gigabytes and terabytes.");
334 ret = -1;
335 goto out;
336 }
337 img_size = (uint64_t)sval;
338 }
339
340 if (options && !strcmp(options, "?")) {
341 ret = print_block_option_help(filename, fmt);
342 goto out;
343 }
344
345 ret = bdrv_img_create(filename, fmt, base_filename, base_fmt,
346 options, img_size, BDRV_O_FLAGS);
347 out:
348 if (ret) {
349 return 1;
350 }
351 return 0;
352 }
353
354 /*
355 * Checks an image for consistency. Exit codes:
356 *
357 * 0 - Check completed, image is good
358 * 1 - Check not completed because of internal errors
359 * 2 - Check completed, image is corrupted
360 * 3 - Check completed, image has leaked clusters, but is good otherwise
361 */
362 static int img_check(int argc, char **argv)
363 {
364 int c, ret;
365 const char *filename, *fmt;
366 BlockDriverState *bs;
367 BdrvCheckResult result;
368
369 fmt = NULL;
370 for(;;) {
371 c = getopt(argc, argv, "f:h");
372 if (c == -1) {
373 break;
374 }
375 switch(c) {
376 case '?':
377 case 'h':
378 help();
379 break;
380 case 'f':
381 fmt = optarg;
382 break;
383 }
384 }
385 if (optind >= argc) {
386 help();
387 }
388 filename = argv[optind++];
389
390 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS);
391 if (!bs) {
392 return 1;
393 }
394 ret = bdrv_check(bs, &result);
395
396 if (ret == -ENOTSUP) {
397 error_report("This image format does not support checks");
398 bdrv_delete(bs);
399 return 1;
400 }
401
402 if (!(result.corruptions || result.leaks || result.check_errors)) {
403 printf("No errors were found on the image.\n");
404 } else {
405 if (result.corruptions) {
406 printf("\n%d errors were found on the image.\n"
407 "Data may be corrupted, or further writes to the image "
408 "may corrupt it.\n",
409 result.corruptions);
410 }
411
412 if (result.leaks) {
413 printf("\n%d leaked clusters were found on the image.\n"
414 "This means waste of disk space, but no harm to data.\n",
415 result.leaks);
416 }
417
418 if (result.check_errors) {
419 printf("\n%d internal errors have occurred during the check.\n",
420 result.check_errors);
421 }
422 }
423
424 bdrv_delete(bs);
425
426 if (ret < 0 || result.check_errors) {
427 printf("\nAn error has occurred during the check: %s\n"
428 "The check is not complete and may have missed error.\n",
429 strerror(-ret));
430 return 1;
431 }
432
433 if (result.corruptions) {
434 return 2;
435 } else if (result.leaks) {
436 return 3;
437 } else {
438 return 0;
439 }
440 }
441
442 static int img_commit(int argc, char **argv)
443 {
444 int c, ret;
445 const char *filename, *fmt;
446 BlockDriverState *bs;
447
448 fmt = NULL;
449 for(;;) {
450 c = getopt(argc, argv, "f:h");
451 if (c == -1) {
452 break;
453 }
454 switch(c) {
455 case '?':
456 case 'h':
457 help();
458 break;
459 case 'f':
460 fmt = optarg;
461 break;
462 }
463 }
464 if (optind >= argc) {
465 help();
466 }
467 filename = argv[optind++];
468
469 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR);
470 if (!bs) {
471 return 1;
472 }
473 ret = bdrv_commit(bs);
474 switch(ret) {
475 case 0:
476 printf("Image committed.\n");
477 break;
478 case -ENOENT:
479 error_report("No disk inserted");
480 break;
481 case -EACCES:
482 error_report("Image is read-only");
483 break;
484 case -ENOTSUP:
485 error_report("Image is already committed");
486 break;
487 default:
488 error_report("Error while committing image");
489 break;
490 }
491
492 bdrv_delete(bs);
493 if (ret) {
494 return 1;
495 }
496 return 0;
497 }
498
499 /*
500 * Checks whether the sector is not a zero sector.
501 *
502 * Attention! The len must be a multiple of 4 * sizeof(long) due to
503 * restriction of optimizations in this function.
504 */
505 static int is_not_zero(const uint8_t *sector, int len)
506 {
507 /*
508 * Use long as the biggest available internal data type that fits into the
509 * CPU register and unroll the loop to smooth out the effect of memory
510 * latency.
511 */
512
513 int i;
514 long d0, d1, d2, d3;
515 const long * const data = (const long *) sector;
516
517 len /= sizeof(long);
518
519 for(i = 0; i < len; i += 4) {
520 d0 = data[i + 0];
521 d1 = data[i + 1];
522 d2 = data[i + 2];
523 d3 = data[i + 3];
524
525 if (d0 || d1 || d2 || d3) {
526 return 1;
527 }
528 }
529
530 return 0;
531 }
532
533 /*
534 * Returns true iff the first sector pointed to by 'buf' contains at least
535 * a non-NUL byte.
536 *
537 * 'pnum' is set to the number of sectors (including and immediately following
538 * the first one) that are known to be in the same allocated/unallocated state.
539 */
540 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
541 {
542 int v, i;
543
544 if (n <= 0) {
545 *pnum = 0;
546 return 0;
547 }
548 v = is_not_zero(buf, 512);
549 for(i = 1; i < n; i++) {
550 buf += 512;
551 if (v != is_not_zero(buf, 512))
552 break;
553 }
554 *pnum = i;
555 return v;
556 }
557
558 /*
559 * Compares two buffers sector by sector. Returns 0 if the first sector of both
560 * buffers matches, non-zero otherwise.
561 *
562 * pnum is set to the number of sectors (including and immediately following
563 * the first one) that are known to have the same comparison result
564 */
565 static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
566 int *pnum)
567 {
568 int res, i;
569
570 if (n <= 0) {
571 *pnum = 0;
572 return 0;
573 }
574
575 res = !!memcmp(buf1, buf2, 512);
576 for(i = 1; i < n; i++) {
577 buf1 += 512;
578 buf2 += 512;
579
580 if (!!memcmp(buf1, buf2, 512) != res) {
581 break;
582 }
583 }
584
585 *pnum = i;
586 return res;
587 }
588
589 #define IO_BUF_SIZE (2 * 1024 * 1024)
590
591 static int img_convert(int argc, char **argv)
592 {
593 int c, ret = 0, n, n1, bs_n, bs_i, compress, cluster_size, cluster_sectors;
594 int progress = 0;
595 const char *fmt, *out_fmt, *out_baseimg, *out_filename;
596 BlockDriver *drv, *proto_drv;
597 BlockDriverState **bs = NULL, *out_bs = NULL;
598 int64_t total_sectors, nb_sectors, sector_num, bs_offset;
599 uint64_t bs_sectors;
600 uint8_t * buf = NULL;
601 const uint8_t *buf1;
602 BlockDriverInfo bdi;
603 QEMUOptionParameter *param = NULL, *create_options = NULL;
604 QEMUOptionParameter *out_baseimg_param;
605 char *options = NULL;
606 const char *snapshot_name = NULL;
607 float local_progress;
608
609 fmt = NULL;
610 out_fmt = "raw";
611 out_baseimg = NULL;
612 compress = 0;
613 for(;;) {
614 c = getopt(argc, argv, "f:O:B:s:hce6o:p");
615 if (c == -1) {
616 break;
617 }
618 switch(c) {
619 case '?':
620 case 'h':
621 help();
622 break;
623 case 'f':
624 fmt = optarg;
625 break;
626 case 'O':
627 out_fmt = optarg;
628 break;
629 case 'B':
630 out_baseimg = optarg;
631 break;
632 case 'c':
633 compress = 1;
634 break;
635 case 'e':
636 error_report("qemu-img: option -e is deprecated, please use \'-o "
637 "encryption\' instead!");
638 return 1;
639 case '6':
640 error_report("qemu-img: option -6 is deprecated, please use \'-o "
641 "compat6\' instead!");
642 return 1;
643 case 'o':
644 options = optarg;
645 break;
646 case 's':
647 snapshot_name = optarg;
648 break;
649 case 'p':
650 progress = 1;
651 break;
652 }
653 }
654
655 bs_n = argc - optind - 1;
656 if (bs_n < 1) {
657 help();
658 }
659
660 out_filename = argv[argc - 1];
661
662 if (options && !strcmp(options, "?")) {
663 ret = print_block_option_help(out_filename, out_fmt);
664 goto out;
665 }
666
667 if (bs_n > 1 && out_baseimg) {
668 error_report("-B makes no sense when concatenating multiple input "
669 "images");
670 ret = -1;
671 goto out;
672 }
673
674 qemu_progress_init(progress, 2.0);
675 qemu_progress_print(0, 100);
676
677 bs = qemu_mallocz(bs_n * sizeof(BlockDriverState *));
678
679 total_sectors = 0;
680 for (bs_i = 0; bs_i < bs_n; bs_i++) {
681 bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, BDRV_O_FLAGS);
682 if (!bs[bs_i]) {
683 error_report("Could not open '%s'", argv[optind + bs_i]);
684 ret = -1;
685 goto out;
686 }
687 bdrv_get_geometry(bs[bs_i], &bs_sectors);
688 total_sectors += bs_sectors;
689 }
690
691 if (snapshot_name != NULL) {
692 if (bs_n > 1) {
693 error_report("No support for concatenating multiple snapshot\n");
694 ret = -1;
695 goto out;
696 }
697 if (bdrv_snapshot_load_tmp(bs[0], snapshot_name) < 0) {
698 error_report("Failed to load snapshot\n");
699 ret = -1;
700 goto out;
701 }
702 }
703
704 /* Find driver and parse its options */
705 drv = bdrv_find_format(out_fmt);
706 if (!drv) {
707 error_report("Unknown file format '%s'", out_fmt);
708 ret = -1;
709 goto out;
710 }
711
712 proto_drv = bdrv_find_protocol(out_filename);
713 if (!proto_drv) {
714 error_report("Unknown protocol '%s'", out_filename);
715 ret = -1;
716 goto out;
717 }
718
719 create_options = append_option_parameters(create_options,
720 drv->create_options);
721 create_options = append_option_parameters(create_options,
722 proto_drv->create_options);
723
724 if (options) {
725 param = parse_option_parameters(options, create_options, param);
726 if (param == NULL) {
727 error_report("Invalid options for file format '%s'.", out_fmt);
728 ret = -1;
729 goto out;
730 }
731 } else {
732 param = parse_option_parameters("", create_options, param);
733 }
734
735 set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
736 ret = add_old_style_options(out_fmt, param, out_baseimg, NULL);
737 if (ret < 0) {
738 goto out;
739 }
740
741 /* Get backing file name if -o backing_file was used */
742 out_baseimg_param = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
743 if (out_baseimg_param) {
744 out_baseimg = out_baseimg_param->value.s;
745 }
746
747 /* Check if compression is supported */
748 if (compress) {
749 QEMUOptionParameter *encryption =
750 get_option_parameter(param, BLOCK_OPT_ENCRYPT);
751
752 if (!drv->bdrv_write_compressed) {
753 error_report("Compression not supported for this file format");
754 ret = -1;
755 goto out;
756 }
757
758 if (encryption && encryption->value.n) {
759 error_report("Compression and encryption not supported at "
760 "the same time");
761 ret = -1;
762 goto out;
763 }
764 }
765
766 /* Create the new image */
767 ret = bdrv_create(drv, out_filename, param);
768 if (ret < 0) {
769 if (ret == -ENOTSUP) {
770 error_report("Formatting not supported for file format '%s'",
771 out_fmt);
772 } else if (ret == -EFBIG) {
773 error_report("The image size is too large for file format '%s'",
774 out_fmt);
775 } else {
776 error_report("%s: error while converting %s: %s",
777 out_filename, out_fmt, strerror(-ret));
778 }
779 goto out;
780 }
781
782 out_bs = bdrv_new_open(out_filename, out_fmt,
783 BDRV_O_FLAGS | BDRV_O_RDWR | BDRV_O_NO_FLUSH);
784 if (!out_bs) {
785 ret = -1;
786 goto out;
787 }
788
789 bs_i = 0;
790 bs_offset = 0;
791 bdrv_get_geometry(bs[0], &bs_sectors);
792 buf = qemu_malloc(IO_BUF_SIZE);
793
794 if (compress) {
795 ret = bdrv_get_info(out_bs, &bdi);
796 if (ret < 0) {
797 error_report("could not get block driver info");
798 goto out;
799 }
800 cluster_size = bdi.cluster_size;
801 if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) {
802 error_report("invalid cluster size");
803 ret = -1;
804 goto out;
805 }
806 cluster_sectors = cluster_size >> 9;
807 sector_num = 0;
808
809 nb_sectors = total_sectors;
810 local_progress = (float)100 /
811 (nb_sectors / MIN(nb_sectors, cluster_sectors));
812
813 for(;;) {
814 int64_t bs_num;
815 int remainder;
816 uint8_t *buf2;
817
818 nb_sectors = total_sectors - sector_num;
819 if (nb_sectors <= 0)
820 break;
821 if (nb_sectors >= cluster_sectors)
822 n = cluster_sectors;
823 else
824 n = nb_sectors;
825
826 bs_num = sector_num - bs_offset;
827 assert (bs_num >= 0);
828 remainder = n;
829 buf2 = buf;
830 while (remainder > 0) {
831 int nlow;
832 while (bs_num == bs_sectors) {
833 bs_i++;
834 assert (bs_i < bs_n);
835 bs_offset += bs_sectors;
836 bdrv_get_geometry(bs[bs_i], &bs_sectors);
837 bs_num = 0;
838 /* printf("changing part: sector_num=%" PRId64 ", "
839 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
840 "\n", sector_num, bs_i, bs_offset, bs_sectors); */
841 }
842 assert (bs_num < bs_sectors);
843
844 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;
845
846 ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow);
847 if (ret < 0) {
848 error_report("error while reading");
849 goto out;
850 }
851
852 buf2 += nlow * 512;
853 bs_num += nlow;
854
855 remainder -= nlow;
856 }
857 assert (remainder == 0);
858
859 if (n < cluster_sectors) {
860 memset(buf + n * 512, 0, cluster_size - n * 512);
861 }
862 if (is_not_zero(buf, cluster_size)) {
863 ret = bdrv_write_compressed(out_bs, sector_num, buf,
864 cluster_sectors);
865 if (ret != 0) {
866 error_report("error while compressing sector %" PRId64,
867 sector_num);
868 goto out;
869 }
870 }
871 sector_num += n;
872 qemu_progress_print(local_progress, 100);
873 }
874 /* signal EOF to align */
875 bdrv_write_compressed(out_bs, 0, NULL, 0);
876 } else {
877 int has_zero_init = bdrv_has_zero_init(out_bs);
878
879 sector_num = 0; // total number of sectors converted so far
880 nb_sectors = total_sectors - sector_num;
881 local_progress = (float)100 /
882 (nb_sectors / MIN(nb_sectors, IO_BUF_SIZE / 512));
883
884 for(;;) {
885 nb_sectors = total_sectors - sector_num;
886 if (nb_sectors <= 0) {
887 break;
888 }
889 if (nb_sectors >= (IO_BUF_SIZE / 512)) {
890 n = (IO_BUF_SIZE / 512);
891 } else {
892 n = nb_sectors;
893 }
894
895 while (sector_num - bs_offset >= bs_sectors) {
896 bs_i ++;
897 assert (bs_i < bs_n);
898 bs_offset += bs_sectors;
899 bdrv_get_geometry(bs[bs_i], &bs_sectors);
900 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
901 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
902 sector_num, bs_i, bs_offset, bs_sectors); */
903 }
904
905 if (n > bs_offset + bs_sectors - sector_num) {
906 n = bs_offset + bs_sectors - sector_num;
907 }
908
909 if (has_zero_init) {
910 /* If the output image is being created as a copy on write image,
911 assume that sectors which are unallocated in the input image
912 are present in both the output's and input's base images (no
913 need to copy them). */
914 if (out_baseimg) {
915 if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
916 n, &n1)) {
917 sector_num += n1;
918 continue;
919 }
920 /* The next 'n1' sectors are allocated in the input image. Copy
921 only those as they may be followed by unallocated sectors. */
922 n = n1;
923 }
924 } else {
925 n1 = n;
926 }
927
928 ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
929 if (ret < 0) {
930 error_report("error while reading");
931 goto out;
932 }
933 /* NOTE: at the same time we convert, we do not write zero
934 sectors to have a chance to compress the image. Ideally, we
935 should add a specific call to have the info to go faster */
936 buf1 = buf;
937 while (n > 0) {
938 /* If the output image is being created as a copy on write image,
939 copy all sectors even the ones containing only NUL bytes,
940 because they may differ from the sectors in the base image.
941
942 If the output is to a host device, we also write out
943 sectors that are entirely 0, since whatever data was
944 already there is garbage, not 0s. */
945 if (!has_zero_init || out_baseimg ||
946 is_allocated_sectors(buf1, n, &n1)) {
947 ret = bdrv_write(out_bs, sector_num, buf1, n1);
948 if (ret < 0) {
949 error_report("error while writing");
950 goto out;
951 }
952 }
953 sector_num += n1;
954 n -= n1;
955 buf1 += n1 * 512;
956 }
957 qemu_progress_print(local_progress, 100);
958 }
959 }
960 out:
961 qemu_progress_end();
962 free_option_parameters(create_options);
963 free_option_parameters(param);
964 qemu_free(buf);
965 if (out_bs) {
966 bdrv_delete(out_bs);
967 }
968 if (bs) {
969 for (bs_i = 0; bs_i < bs_n; bs_i++) {
970 if (bs[bs_i]) {
971 bdrv_delete(bs[bs_i]);
972 }
973 }
974 qemu_free(bs);
975 }
976 if (ret) {
977 return 1;
978 }
979 return 0;
980 }
981
982 #ifdef _WIN32
983 static int64_t get_allocated_file_size(const char *filename)
984 {
985 typedef DWORD (WINAPI * get_compressed_t)(const char *filename, DWORD *high);
986 get_compressed_t get_compressed;
987 struct _stati64 st;
988
989 /* WinNT support GetCompressedFileSize to determine allocate size */
990 get_compressed = (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA");
991 if (get_compressed) {
992 DWORD high, low;
993 low = get_compressed(filename, &high);
994 if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR)
995 return (((int64_t) high) << 32) + low;
996 }
997
998 if (_stati64(filename, &st) < 0)
999 return -1;
1000 return st.st_size;
1001 }
1002 #else
1003 static int64_t get_allocated_file_size(const char *filename)
1004 {
1005 struct stat st;
1006 if (stat(filename, &st) < 0)
1007 return -1;
1008 return (int64_t)st.st_blocks * 512;
1009 }
1010 #endif
1011
1012 static void dump_snapshots(BlockDriverState *bs)
1013 {
1014 QEMUSnapshotInfo *sn_tab, *sn;
1015 int nb_sns, i;
1016 char buf[256];
1017
1018 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1019 if (nb_sns <= 0)
1020 return;
1021 printf("Snapshot list:\n");
1022 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
1023 for(i = 0; i < nb_sns; i++) {
1024 sn = &sn_tab[i];
1025 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
1026 }
1027 qemu_free(sn_tab);
1028 }
1029
1030 static int img_info(int argc, char **argv)
1031 {
1032 int c;
1033 const char *filename, *fmt;
1034 BlockDriverState *bs;
1035 char fmt_name[128], size_buf[128], dsize_buf[128];
1036 uint64_t total_sectors;
1037 int64_t allocated_size;
1038 char backing_filename[1024];
1039 char backing_filename2[1024];
1040 BlockDriverInfo bdi;
1041
1042 fmt = NULL;
1043 for(;;) {
1044 c = getopt(argc, argv, "f:h");
1045 if (c == -1) {
1046 break;
1047 }
1048 switch(c) {
1049 case '?':
1050 case 'h':
1051 help();
1052 break;
1053 case 'f':
1054 fmt = optarg;
1055 break;
1056 }
1057 }
1058 if (optind >= argc) {
1059 help();
1060 }
1061 filename = argv[optind++];
1062
1063 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING);
1064 if (!bs) {
1065 return 1;
1066 }
1067 bdrv_get_format(bs, fmt_name, sizeof(fmt_name));
1068 bdrv_get_geometry(bs, &total_sectors);
1069 get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512);
1070 allocated_size = get_allocated_file_size(filename);
1071 if (allocated_size < 0) {
1072 snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
1073 } else {
1074 get_human_readable_size(dsize_buf, sizeof(dsize_buf),
1075 allocated_size);
1076 }
1077 printf("image: %s\n"
1078 "file format: %s\n"
1079 "virtual size: %s (%" PRId64 " bytes)\n"
1080 "disk size: %s\n",
1081 filename, fmt_name, size_buf,
1082 (total_sectors * 512),
1083 dsize_buf);
1084 if (bdrv_is_encrypted(bs)) {
1085 printf("encrypted: yes\n");
1086 }
1087 if (bdrv_get_info(bs, &bdi) >= 0) {
1088 if (bdi.cluster_size != 0) {
1089 printf("cluster_size: %d\n", bdi.cluster_size);
1090 }
1091 }
1092 bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
1093 if (backing_filename[0] != '\0') {
1094 path_combine(backing_filename2, sizeof(backing_filename2),
1095 filename, backing_filename);
1096 printf("backing file: %s (actual path: %s)\n",
1097 backing_filename,
1098 backing_filename2);
1099 }
1100 dump_snapshots(bs);
1101 bdrv_delete(bs);
1102 return 0;
1103 }
1104
1105 #define SNAPSHOT_LIST 1
1106 #define SNAPSHOT_CREATE 2
1107 #define SNAPSHOT_APPLY 3
1108 #define SNAPSHOT_DELETE 4
1109
1110 static int img_snapshot(int argc, char **argv)
1111 {
1112 BlockDriverState *bs;
1113 QEMUSnapshotInfo sn;
1114 char *filename, *snapshot_name = NULL;
1115 int c, ret = 0, bdrv_oflags;
1116 int action = 0;
1117 qemu_timeval tv;
1118
1119 bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
1120 /* Parse commandline parameters */
1121 for(;;) {
1122 c = getopt(argc, argv, "la:c:d:h");
1123 if (c == -1) {
1124 break;
1125 }
1126 switch(c) {
1127 case '?':
1128 case 'h':
1129 help();
1130 return 0;
1131 case 'l':
1132 if (action) {
1133 help();
1134 return 0;
1135 }
1136 action = SNAPSHOT_LIST;
1137 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
1138 break;
1139 case 'a':
1140 if (action) {
1141 help();
1142 return 0;
1143 }
1144 action = SNAPSHOT_APPLY;
1145 snapshot_name = optarg;
1146 break;
1147 case 'c':
1148 if (action) {
1149 help();
1150 return 0;
1151 }
1152 action = SNAPSHOT_CREATE;
1153 snapshot_name = optarg;
1154 break;
1155 case 'd':
1156 if (action) {
1157 help();
1158 return 0;
1159 }
1160 action = SNAPSHOT_DELETE;
1161 snapshot_name = optarg;
1162 break;
1163 }
1164 }
1165
1166 if (optind >= argc) {
1167 help();
1168 }
1169 filename = argv[optind++];
1170
1171 /* Open the image */
1172 bs = bdrv_new_open(filename, NULL, bdrv_oflags);
1173 if (!bs) {
1174 return 1;
1175 }
1176
1177 /* Perform the requested action */
1178 switch(action) {
1179 case SNAPSHOT_LIST:
1180 dump_snapshots(bs);
1181 break;
1182
1183 case SNAPSHOT_CREATE:
1184 memset(&sn, 0, sizeof(sn));
1185 pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
1186
1187 qemu_gettimeofday(&tv);
1188 sn.date_sec = tv.tv_sec;
1189 sn.date_nsec = tv.tv_usec * 1000;
1190
1191 ret = bdrv_snapshot_create(bs, &sn);
1192 if (ret) {
1193 error_report("Could not create snapshot '%s': %d (%s)",
1194 snapshot_name, ret, strerror(-ret));
1195 }
1196 break;
1197
1198 case SNAPSHOT_APPLY:
1199 ret = bdrv_snapshot_goto(bs, snapshot_name);
1200 if (ret) {
1201 error_report("Could not apply snapshot '%s': %d (%s)",
1202 snapshot_name, ret, strerror(-ret));
1203 }
1204 break;
1205
1206 case SNAPSHOT_DELETE:
1207 ret = bdrv_snapshot_delete(bs, snapshot_name);
1208 if (ret) {
1209 error_report("Could not delete snapshot '%s': %d (%s)",
1210 snapshot_name, ret, strerror(-ret));
1211 }
1212 break;
1213 }
1214
1215 /* Cleanup */
1216 bdrv_delete(bs);
1217 if (ret) {
1218 return 1;
1219 }
1220 return 0;
1221 }
1222
1223 static int img_rebase(int argc, char **argv)
1224 {
1225 BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
1226 BlockDriver *old_backing_drv, *new_backing_drv;
1227 char *filename;
1228 const char *fmt, *out_basefmt, *out_baseimg;
1229 int c, flags, ret;
1230 int unsafe = 0;
1231 int progress = 0;
1232
1233 /* Parse commandline parameters */
1234 fmt = NULL;
1235 out_baseimg = NULL;
1236 out_basefmt = NULL;
1237
1238 for(;;) {
1239 c = getopt(argc, argv, "uhf:F:b:p");
1240 if (c == -1) {
1241 break;
1242 }
1243 switch(c) {
1244 case '?':
1245 case 'h':
1246 help();
1247 return 0;
1248 case 'f':
1249 fmt = optarg;
1250 break;
1251 case 'F':
1252 out_basefmt = optarg;
1253 break;
1254 case 'b':
1255 out_baseimg = optarg;
1256 break;
1257 case 'u':
1258 unsafe = 1;
1259 break;
1260 case 'p':
1261 progress = 1;
1262 break;
1263 }
1264 }
1265
1266 if ((optind >= argc) || (!unsafe && !out_baseimg)) {
1267 help();
1268 }
1269 filename = argv[optind++];
1270
1271 qemu_progress_init(progress, 2.0);
1272 qemu_progress_print(0, 100);
1273
1274 /*
1275 * Open the images.
1276 *
1277 * Ignore the old backing file for unsafe rebase in case we want to correct
1278 * the reference to a renamed or moved backing file.
1279 */
1280 flags = BDRV_O_FLAGS | BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
1281 bs = bdrv_new_open(filename, fmt, flags);
1282 if (!bs) {
1283 return 1;
1284 }
1285
1286 /* Find the right drivers for the backing files */
1287 old_backing_drv = NULL;
1288 new_backing_drv = NULL;
1289
1290 if (!unsafe && bs->backing_format[0] != '\0') {
1291 old_backing_drv = bdrv_find_format(bs->backing_format);
1292 if (old_backing_drv == NULL) {
1293 error_report("Invalid format name: '%s'", bs->backing_format);
1294 ret = -1;
1295 goto out;
1296 }
1297 }
1298
1299 if (out_basefmt != NULL) {
1300 new_backing_drv = bdrv_find_format(out_basefmt);
1301 if (new_backing_drv == NULL) {
1302 error_report("Invalid format name: '%s'", out_basefmt);
1303 ret = -1;
1304 goto out;
1305 }
1306 }
1307
1308 /* For safe rebasing we need to compare old and new backing file */
1309 if (unsafe) {
1310 /* Make the compiler happy */
1311 bs_old_backing = NULL;
1312 bs_new_backing = NULL;
1313 } else {
1314 char backing_name[1024];
1315
1316 bs_old_backing = bdrv_new("old_backing");
1317 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
1318 ret = bdrv_open(bs_old_backing, backing_name, BDRV_O_FLAGS,
1319 old_backing_drv);
1320 if (ret) {
1321 error_report("Could not open old backing file '%s'", backing_name);
1322 goto out;
1323 }
1324
1325 bs_new_backing = bdrv_new("new_backing");
1326 ret = bdrv_open(bs_new_backing, out_baseimg, BDRV_O_FLAGS,
1327 new_backing_drv);
1328 if (ret) {
1329 error_report("Could not open new backing file '%s'", out_baseimg);
1330 goto out;
1331 }
1332 }
1333
1334 /*
1335 * Check each unallocated cluster in the COW file. If it is unallocated,
1336 * accesses go to the backing file. We must therefore compare this cluster
1337 * in the old and new backing file, and if they differ we need to copy it
1338 * from the old backing file into the COW file.
1339 *
1340 * If qemu-img crashes during this step, no harm is done. The content of
1341 * the image is the same as the original one at any time.
1342 */
1343 if (!unsafe) {
1344 uint64_t num_sectors;
1345 uint64_t sector;
1346 int n;
1347 uint8_t * buf_old;
1348 uint8_t * buf_new;
1349 float local_progress;
1350
1351 buf_old = qemu_malloc(IO_BUF_SIZE);
1352 buf_new = qemu_malloc(IO_BUF_SIZE);
1353
1354 bdrv_get_geometry(bs, &num_sectors);
1355
1356 local_progress = (float)100 /
1357 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
1358 for (sector = 0; sector < num_sectors; sector += n) {
1359
1360 /* How many sectors can we handle with the next read? */
1361 if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
1362 n = (IO_BUF_SIZE / 512);
1363 } else {
1364 n = num_sectors - sector;
1365 }
1366
1367 /* If the cluster is allocated, we don't need to take action */
1368 ret = bdrv_is_allocated(bs, sector, n, &n);
1369 if (ret) {
1370 continue;
1371 }
1372
1373 /* Read old and new backing file */
1374 ret = bdrv_read(bs_old_backing, sector, buf_old, n);
1375 if (ret < 0) {
1376 error_report("error while reading from old backing file");
1377 goto out;
1378 }
1379 ret = bdrv_read(bs_new_backing, sector, buf_new, n);
1380 if (ret < 0) {
1381 error_report("error while reading from new backing file");
1382 goto out;
1383 }
1384
1385 /* If they differ, we need to write to the COW file */
1386 uint64_t written = 0;
1387
1388 while (written < n) {
1389 int pnum;
1390
1391 if (compare_sectors(buf_old + written * 512,
1392 buf_new + written * 512, n - written, &pnum))
1393 {
1394 ret = bdrv_write(bs, sector + written,
1395 buf_old + written * 512, pnum);
1396 if (ret < 0) {
1397 error_report("Error while writing to COW image: %s",
1398 strerror(-ret));
1399 goto out;
1400 }
1401 }
1402
1403 written += pnum;
1404 }
1405 qemu_progress_print(local_progress, 100);
1406 }
1407
1408 qemu_free(buf_old);
1409 qemu_free(buf_new);
1410 }
1411
1412 /*
1413 * Change the backing file. All clusters that are different from the old
1414 * backing file are overwritten in the COW file now, so the visible content
1415 * doesn't change when we switch the backing file.
1416 */
1417 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
1418 if (ret == -ENOSPC) {
1419 error_report("Could not change the backing file to '%s': No "
1420 "space left in the file header", out_baseimg);
1421 } else if (ret < 0) {
1422 error_report("Could not change the backing file to '%s': %s",
1423 out_baseimg, strerror(-ret));
1424 }
1425
1426 qemu_progress_print(100, 0);
1427 /*
1428 * TODO At this point it is possible to check if any clusters that are
1429 * allocated in the COW file are the same in the backing file. If so, they
1430 * could be dropped from the COW file. Don't do this before switching the
1431 * backing file, in case of a crash this would lead to corruption.
1432 */
1433 out:
1434 qemu_progress_end();
1435 /* Cleanup */
1436 if (!unsafe) {
1437 if (bs_old_backing != NULL) {
1438 bdrv_delete(bs_old_backing);
1439 }
1440 if (bs_new_backing != NULL) {
1441 bdrv_delete(bs_new_backing);
1442 }
1443 }
1444
1445 bdrv_delete(bs);
1446 if (ret) {
1447 return 1;
1448 }
1449 return 0;
1450 }
1451
1452 static int img_resize(int argc, char **argv)
1453 {
1454 int c, ret, relative;
1455 const char *filename, *fmt, *size;
1456 int64_t n, total_size;
1457 BlockDriverState *bs = NULL;
1458 QEMUOptionParameter *param;
1459 QEMUOptionParameter resize_options[] = {
1460 {
1461 .name = BLOCK_OPT_SIZE,
1462 .type = OPT_SIZE,
1463 .help = "Virtual disk size"
1464 },
1465 { NULL }
1466 };
1467
1468 /* Remove size from argv manually so that negative numbers are not treated
1469 * as options by getopt. */
1470 if (argc < 3) {
1471 help();
1472 return 1;
1473 }
1474
1475 size = argv[--argc];
1476
1477 /* Parse getopt arguments */
1478 fmt = NULL;
1479 for(;;) {
1480 c = getopt(argc, argv, "f:h");
1481 if (c == -1) {
1482 break;
1483 }
1484 switch(c) {
1485 case '?':
1486 case 'h':
1487 help();
1488 break;
1489 case 'f':
1490 fmt = optarg;
1491 break;
1492 }
1493 }
1494 if (optind >= argc) {
1495 help();
1496 }
1497 filename = argv[optind++];
1498
1499 /* Choose grow, shrink, or absolute resize mode */
1500 switch (size[0]) {
1501 case '+':
1502 relative = 1;
1503 size++;
1504 break;
1505 case '-':
1506 relative = -1;
1507 size++;
1508 break;
1509 default:
1510 relative = 0;
1511 break;
1512 }
1513
1514 /* Parse size */
1515 param = parse_option_parameters("", resize_options, NULL);
1516 if (set_option_parameter(param, BLOCK_OPT_SIZE, size)) {
1517 /* Error message already printed when size parsing fails */
1518 ret = -1;
1519 goto out;
1520 }
1521 n = get_option_parameter(param, BLOCK_OPT_SIZE)->value.n;
1522 free_option_parameters(param);
1523
1524 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR);
1525 if (!bs) {
1526 ret = -1;
1527 goto out;
1528 }
1529
1530 if (relative) {
1531 total_size = bdrv_getlength(bs) + n * relative;
1532 } else {
1533 total_size = n;
1534 }
1535 if (total_size <= 0) {
1536 error_report("New image size must be positive");
1537 ret = -1;
1538 goto out;
1539 }
1540
1541 ret = bdrv_truncate(bs, total_size);
1542 switch (ret) {
1543 case 0:
1544 printf("Image resized.\n");
1545 break;
1546 case -ENOTSUP:
1547 error_report("This image format does not support resize");
1548 break;
1549 case -EACCES:
1550 error_report("Image is read-only");
1551 break;
1552 default:
1553 error_report("Error resizing image (%d)", -ret);
1554 break;
1555 }
1556 out:
1557 if (bs) {
1558 bdrv_delete(bs);
1559 }
1560 if (ret) {
1561 return 1;
1562 }
1563 return 0;
1564 }
1565
1566 static const img_cmd_t img_cmds[] = {
1567 #define DEF(option, callback, arg_string) \
1568 { option, callback },
1569 #include "qemu-img-cmds.h"
1570 #undef DEF
1571 #undef GEN_DOCS
1572 { NULL, NULL, },
1573 };
1574
1575 int main(int argc, char **argv)
1576 {
1577 const img_cmd_t *cmd;
1578 const char *cmdname;
1579
1580 error_set_progname(argv[0]);
1581
1582 bdrv_init();
1583 if (argc < 2)
1584 help();
1585 cmdname = argv[1];
1586 argc--; argv++;
1587
1588 /* find the command */
1589 for(cmd = img_cmds; cmd->name != NULL; cmd++) {
1590 if (!strcmp(cmdname, cmd->name)) {
1591 return cmd->handler(argc, argv);
1592 }
1593 }
1594
1595 /* not found */
1596 help();
1597 return 0;
1598 }