Bug Summary

File:qemu-img.c
Location:line 984, column 14
Description:Division by zero

Annotated Source Code

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