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