?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
target-i386: Introduce X86CPU::filtered_features field
[qemu.git] / qemu-img.c
blobcd096a136153811f05a7e9268ebdb08164e5ddf3
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 "qapi/qmp/qjson.h"
27 #include "qemu-common.h"
28 #include "qemu/option.h"
29 #include "qemu/error-report.h"
30 #include "qemu/osdep.h"
31 #include "sysemu/sysemu.h"
32 #include "block/block_int.h"
33 #include <getopt.h>
34 #include <stdio.h>
35 #include <stdarg.h>
36
37 #ifdef _WIN32
38 #include <windows.h>
39 #endif
40
41 typedef struct img_cmd_t {
42 const char *name;
43 int (*handler)(int argc, char **argv);
44 } img_cmd_t;
45
46 enum {
47 OPTION_OUTPUT = 256,
48 OPTION_BACKING_CHAIN = 257,
49 };
50
51 typedef enum OutputFormat {
52 OFORMAT_JSON,
53 OFORMAT_HUMAN,
54 } OutputFormat;
55
56 /* Default to cache=writeback as data integrity is not important for qemu-tcg. */
57 #define BDRV_O_FLAGS BDRV_O_CACHE_WB
58 #define BDRV_DEFAULT_CACHE "writeback"
59
60 static void format_print(void *opaque, const char *name)
61 {
62 printf(" %s", name);
63 }
64
65 /* Please keep in synch with qemu-img.texi */
66 static void help(void)
67 {
68 const char *help_msg =
69 "qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n"
70 "usage: qemu-img command [command options]\n"
71 "QEMU disk image utility\n"
72 "\n"
73 "Command syntax:\n"
74 #define DEF(option, callback, arg_string) \
75 " " arg_string "\n"
76 #include "qemu-img-cmds.h"
77 #undef DEF
78 #undef GEN_DOCS
79 "\n"
80 "Command parameters:\n"
81 " 'filename' is a disk image filename\n"
82 " 'fmt' is the disk image format. It is guessed automatically in most cases\n"
83 " 'cache' is the cache mode used to write the output disk image, the valid\n"
84 " options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n"
85 " 'directsync' and 'unsafe' (default for convert)\n"
86 " 'size' is the disk image size in bytes. Optional suffixes\n"
87 " 'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n"
88 " and T (terabyte, 1024G) are supported. 'b' is ignored.\n"
89 " 'output_filename' is the destination disk image filename\n"
90 " 'output_fmt' is the destination format\n"
91 " 'options' is a comma separated list of format specific options in a\n"
92 " name=value format. Use -o ? for an overview of the options supported by the\n"
93 " used format\n"
94 " '-c' indicates that target image must be compressed (qcow format only)\n"
95 " '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
96 " match exactly. The image doesn't need a working backing file before\n"
97 " rebasing in this case (useful for renaming the backing file)\n"
98 " '-h' with or without a command shows this help and lists the supported formats\n"
99 " '-p' show progress of command (only certain commands)\n"
100 " '-q' use Quiet mode - do not print any output (except errors)\n"
101 " '-S' indicates the consecutive number of bytes that must contain only zeros\n"
102 " for qemu-img to create a sparse image during conversion\n"
103 " '--output' takes the format in which the output must be done (human or json)\n"
104 "\n"
105 "Parameters to check subcommand:\n"
106 " '-r' tries to repair any inconsistencies that are found during the check.\n"
107 " '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n"
108 " kinds of errors, with a higher risk of choosing the wrong fix or\n"
109 " hiding corruption that has already occurred.\n"
110 "\n"
111 "Parameters to snapshot subcommand:\n"
112 " 'snapshot' is the name of the snapshot to create, apply or delete\n"
113 " '-a' applies a snapshot (revert disk to saved state)\n"
114 " '-c' creates a snapshot\n"
115 " '-d' deletes a snapshot\n"
116 " '-l' lists all snapshots in the given image\n"
117 "\n"
118 "Parameters to compare subcommand:\n"
119 " '-f' first image format\n"
120 " '-F' second image format\n"
121 " '-s' run in Strict mode - fail on different image size or sector allocation\n";
122
123 printf("%s\nSupported formats:", help_msg);
124 bdrv_iterate_format(format_print, NULL);
125 printf("\n");
126 exit(1);
127 }
128
129 static int qprintf(bool quiet, const char *fmt, ...)
130 {
131 int ret = 0;
132 if (!quiet) {
133 va_list args;
134 va_start(args, fmt);
135 ret = vprintf(fmt, args);
136 va_end(args);
137 }
138 return ret;
139 }
140
141 #if defined(WIN32)
142 /* XXX: put correct support for win32 */
143 static int read_password(char *buf, int buf_size)
144 {
145 int c, i;
146 printf("Password: ");
147 fflush(stdout);
148 i = 0;
149 for(;;) {
150 c = getchar();
151 if (c == '\n')
152 break;
153 if (i < (buf_size - 1))
154 buf[i++] = c;
155 }
156 buf[i] = '\0';
157 return 0;
158 }
159
160 #else
161
162 #include <termios.h>
163
164 static struct termios oldtty;
165
166 static void term_exit(void)
167 {
168 tcsetattr (0, TCSANOW, &oldtty);
169 }
170
171 static void term_init(void)
172 {
173 struct termios tty;
174
175 tcgetattr (0, &tty);
176 oldtty = tty;
177
178 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
179 |INLCR|IGNCR|ICRNL|IXON);
180 tty.c_oflag |= OPOST;
181 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
182 tty.c_cflag &= ~(CSIZE|PARENB);
183 tty.c_cflag |= CS8;
184 tty.c_cc[VMIN] = 1;
185 tty.c_cc[VTIME] = 0;
186
187 tcsetattr (0, TCSANOW, &tty);
188
189 atexit(term_exit);
190 }
191
192 static int read_password(char *buf, int buf_size)
193 {
194 uint8_t ch;
195 int i, ret;
196
197 printf("password: ");
198 fflush(stdout);
199 term_init();
200 i = 0;
201 for(;;) {
202 ret = read(0, &ch, 1);
203 if (ret == -1) {
204 if (errno == EAGAIN || errno == EINTR) {
205 continue;
206 } else {
207 ret = -1;
208 break;
209 }
210 } else if (ret == 0) {
211 ret = -1;
212 break;
213 } else {
214 if (ch == '\r') {
215 ret = 0;
216 break;
217 }
218 if (i < (buf_size - 1))
219 buf[i++] = ch;
220 }
221 }
222 term_exit();
223 buf[i] = '\0';
224 printf("\n");
225 return ret;
226 }
227 #endif
228
229 static int print_block_option_help(const char *filename, const char *fmt)
230 {
231 BlockDriver *drv, *proto_drv;
232 QEMUOptionParameter *create_options = NULL;
233
234 /* Find driver and parse its options */
235 drv = bdrv_find_format(fmt);
236 if (!drv) {
237 error_report("Unknown file format '%s'", fmt);
238 return 1;
239 }
240
241 proto_drv = bdrv_find_protocol(filename);
242 if (!proto_drv) {
243 error_report("Unknown protocol '%s'", filename);
244 return 1;
245 }
246
247 create_options = append_option_parameters(create_options,
248 drv->create_options);
249 create_options = append_option_parameters(create_options,
250 proto_drv->create_options);
251 print_option_help(create_options);
252 free_option_parameters(create_options);
253 return 0;
254 }
255
256 static BlockDriverState *bdrv_new_open(const char *filename,
257 const char *fmt,
258 int flags,
259 bool require_io,
260 bool quiet)
261 {
262 BlockDriverState *bs;
263 BlockDriver *drv;
264 char password[256];
265 int ret;
266
267 bs = bdrv_new("image");
268
269 if (fmt) {
270 drv = bdrv_find_format(fmt);
271 if (!drv) {
272 error_report("Unknown file format '%s'", fmt);
273 goto fail;
274 }
275 } else {
276 drv = NULL;
277 }
278
279 ret = bdrv_open(bs, filename, NULL, flags, drv);
280 if (ret < 0) {
281 error_report("Could not open '%s': %s", filename, strerror(-ret));
282 goto fail;
283 }
284
285 if (bdrv_is_encrypted(bs) && require_io) {
286 qprintf(quiet, "Disk image '%s' is encrypted.\n", filename);
287 if (read_password(password, sizeof(password)) < 0) {
288 error_report("No password given");
289 goto fail;
290 }
291 if (bdrv_set_key(bs, password) < 0) {
292 error_report("invalid password");
293 goto fail;
294 }
295 }
296 return bs;
297 fail:
298 if (bs) {
299 bdrv_delete(bs);
300 }
301 return NULL;
302 }
303
304 static int add_old_style_options(const char *fmt, QEMUOptionParameter *list,
305 const char *base_filename,
306 const char *base_fmt)
307 {
308 if (base_filename) {
309 if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) {
310 error_report("Backing file not supported for file format '%s'",
311 fmt);
312 return -1;
313 }
314 }
315 if (base_fmt) {
316 if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) {
317 error_report("Backing file format not supported for file "
318 "format '%s'", fmt);
319 return -1;
320 }
321 }
322 return 0;
323 }
324
325 static int img_create(int argc, char **argv)
326 {
327 int c;
328 uint64_t img_size = -1;
329 const char *fmt = "raw";
330 const char *base_fmt = NULL;
331 const char *filename;
332 const char *base_filename = NULL;
333 char *options = NULL;
334 Error *local_err = NULL;
335 bool quiet = false;
336
337 for(;;) {
338 c = getopt(argc, argv, "F:b:f:he6o:q");
339 if (c == -1) {
340 break;
341 }
342 switch(c) {
343 case '?':
344 case 'h':
345 help();
346 break;
347 case 'F':
348 base_fmt = optarg;
349 break;
350 case 'b':
351 base_filename = optarg;
352 break;
353 case 'f':
354 fmt = optarg;
355 break;
356 case 'e':
357 error_report("option -e is deprecated, please use \'-o "
358 "encryption\' instead!");
359 return 1;
360 case '6':
361 error_report("option -6 is deprecated, please use \'-o "
362 "compat6\' instead!");
363 return 1;
364 case 'o':
365 options = optarg;
366 break;
367 case 'q':
368 quiet = true;
369 break;
370 }
371 }
372
373 /* Get the filename */
374 if (optind >= argc) {
375 help();
376 }
377 filename = argv[optind++];
378
379 /* Get image size, if specified */
380 if (optind < argc) {
381 int64_t sval;
382 char *end;
383 sval = strtosz_suffix(argv[optind++], &end, STRTOSZ_DEFSUFFIX_B);
384 if (sval < 0 || *end) {
385 if (sval == -ERANGE) {
386 error_report("Image size must be less than 8 EiB!");
387 } else {
388 error_report("Invalid image size specified! You may use k, M, "
389 "G or T suffixes for ");
390 error_report("kilobytes, megabytes, gigabytes and terabytes.");
391 }
392 return 1;
393 }
394 img_size = (uint64_t)sval;
395 }
396
397 if (options && is_help_option(options)) {
398 return print_block_option_help(filename, fmt);
399 }
400
401 bdrv_img_create(filename, fmt, base_filename, base_fmt,
402 options, img_size, BDRV_O_FLAGS, &local_err, quiet);
403 if (error_is_set(&local_err)) {
404 error_report("%s", error_get_pretty(local_err));
405 error_free(local_err);
406 return 1;
407 }
408
409 return 0;
410 }
411
412 static void dump_json_image_check(ImageCheck *check, bool quiet)
413 {
414 Error *errp = NULL;
415 QString *str;
416 QmpOutputVisitor *ov = qmp_output_visitor_new();
417 QObject *obj;
418 visit_type_ImageCheck(qmp_output_get_visitor(ov),
419 &check, NULL, &errp);
420 obj = qmp_output_get_qobject(ov);
421 str = qobject_to_json_pretty(obj);
422 assert(str != NULL);
423 qprintf(quiet, "%s\n", qstring_get_str(str));
424 qobject_decref(obj);
425 qmp_output_visitor_cleanup(ov);
426 QDECREF(str);
427 }
428
429 static void dump_human_image_check(ImageCheck *check, bool quiet)
430 {
431 if (!(check->corruptions || check->leaks || check->check_errors)) {
432 qprintf(quiet, "No errors were found on the image.\n");
433 } else {
434 if (check->corruptions) {
435 qprintf(quiet, "\n%" PRId64 " errors were found on the image.\n"
436 "Data may be corrupted, or further writes to the image "
437 "may corrupt it.\n",
438 check->corruptions);
439 }
440
441 if (check->leaks) {
442 qprintf(quiet,
443 "\n%" PRId64 " leaked clusters were found on the image.\n"
444 "This means waste of disk space, but no harm to data.\n",
445 check->leaks);
446 }
447
448 if (check->check_errors) {
449 qprintf(quiet,
450 "\n%" PRId64
451 " internal errors have occurred during the check.\n",
452 check->check_errors);
453 }
454 }
455
456 if (check->total_clusters != 0 && check->allocated_clusters != 0) {
457 qprintf(quiet, "%" PRId64 "/%" PRId64 " = %0.2f%% allocated, "
458 "%0.2f%% fragmented, %0.2f%% compressed clusters\n",
459 check->allocated_clusters, check->total_clusters,
460 check->allocated_clusters * 100.0 / check->total_clusters,
461 check->fragmented_clusters * 100.0 / check->allocated_clusters,
462 check->compressed_clusters * 100.0 /
463 check->allocated_clusters);
464 }
465
466 if (check->image_end_offset) {
467 qprintf(quiet,
468 "Image end offset: %" PRId64 "\n", check->image_end_offset);
469 }
470 }
471
472 static int collect_image_check(BlockDriverState *bs,
473 ImageCheck *check,
474 const char *filename,
475 const char *fmt,
476 int fix)
477 {
478 int ret;
479 BdrvCheckResult result;
480
481 ret = bdrv_check(bs, &result, fix);
482 if (ret < 0) {
483 return ret;
484 }
485
486 check->filename = g_strdup(filename);
487 check->format = g_strdup(bdrv_get_format_name(bs));
488 check->check_errors = result.check_errors;
489 check->corruptions = result.corruptions;
490 check->has_corruptions = result.corruptions != 0;
491 check->leaks = result.leaks;
492 check->has_leaks = result.leaks != 0;
493 check->corruptions_fixed = result.corruptions_fixed;
494 check->has_corruptions_fixed = result.corruptions != 0;
495 check->leaks_fixed = result.leaks_fixed;
496 check->has_leaks_fixed = result.leaks != 0;
497 check->image_end_offset = result.image_end_offset;
498 check->has_image_end_offset = result.image_end_offset != 0;
499 check->total_clusters = result.bfi.total_clusters;
500 check->has_total_clusters = result.bfi.total_clusters != 0;
501 check->allocated_clusters = result.bfi.allocated_clusters;
502 check->has_allocated_clusters = result.bfi.allocated_clusters != 0;
503 check->fragmented_clusters = result.bfi.fragmented_clusters;
504 check->has_fragmented_clusters = result.bfi.fragmented_clusters != 0;
505 check->compressed_clusters = result.bfi.compressed_clusters;
506 check->has_compressed_clusters = result.bfi.compressed_clusters != 0;
507
508 return 0;
509 }
510
511 /*
512 * Checks an image for consistency. Exit codes:
513 *
514 * 0 - Check completed, image is good
515 * 1 - Check not completed because of internal errors
516 * 2 - Check completed, image is corrupted
517 * 3 - Check completed, image has leaked clusters, but is good otherwise
518 */
519 static int img_check(int argc, char **argv)
520 {
521 int c, ret;
522 OutputFormat output_format = OFORMAT_HUMAN;
523 const char *filename, *fmt, *output;
524 BlockDriverState *bs;
525 int fix = 0;
526 int flags = BDRV_O_FLAGS | BDRV_O_CHECK;
527 ImageCheck *check;
528 bool quiet = false;
529
530 fmt = NULL;
531 output = NULL;
532 for(;;) {
533 int option_index = 0;
534 static const struct option long_options[] = {
535 {"help", no_argument, 0, 'h'},
536 {"format", required_argument, 0, 'f'},
537 {"repair", no_argument, 0, 'r'},
538 {"output", required_argument, 0, OPTION_OUTPUT},
539 {0, 0, 0, 0}
540 };
541 c = getopt_long(argc, argv, "f:hr:q",
542 long_options, &option_index);
543 if (c == -1) {
544 break;
545 }
546 switch(c) {
547 case '?':
548 case 'h':
549 help();
550 break;
551 case 'f':
552 fmt = optarg;
553 break;
554 case 'r':
555 flags |= BDRV_O_RDWR;
556
557 if (!strcmp(optarg, "leaks")) {
558 fix = BDRV_FIX_LEAKS;
559 } else if (!strcmp(optarg, "all")) {
560 fix = BDRV_FIX_LEAKS | BDRV_FIX_ERRORS;
561 } else {
562 help();
563 }
564 break;
565 case OPTION_OUTPUT:
566 output = optarg;
567 break;
568 case 'q':
569 quiet = true;
570 break;
571 }
572 }
573 if (optind >= argc) {
574 help();
575 }
576 filename = argv[optind++];
577
578 if (output && !strcmp(output, "json")) {
579 output_format = OFORMAT_JSON;
580 } else if (output && !strcmp(output, "human")) {
581 output_format = OFORMAT_HUMAN;
582 } else if (output) {
583 error_report("--output must be used with human or json as argument.");
584 return 1;
585 }
586
587 bs = bdrv_new_open(filename, fmt, flags, true, quiet);
588 if (!bs) {
589 return 1;
590 }
591
592 check = g_new0(ImageCheck, 1);
593 ret = collect_image_check(bs, check, filename, fmt, fix);
594
595 if (ret == -ENOTSUP) {
596 if (output_format == OFORMAT_HUMAN) {
597 error_report("This image format does not support checks");
598 }
599 ret = 1;
600 goto fail;
601 }
602
603 if (check->corruptions_fixed || check->leaks_fixed) {
604 int corruptions_fixed, leaks_fixed;
605
606 leaks_fixed = check->leaks_fixed;
607 corruptions_fixed = check->corruptions_fixed;
608
609 if (output_format == OFORMAT_HUMAN) {
610 qprintf(quiet,
611 "The following inconsistencies were found and repaired:\n\n"
612 " %" PRId64 " leaked clusters\n"
613 " %" PRId64 " corruptions\n\n"
614 "Double checking the fixed image now...\n",
615 check->leaks_fixed,
616 check->corruptions_fixed);
617 }
618
619 ret = collect_image_check(bs, check, filename, fmt, 0);
620
621 check->leaks_fixed = leaks_fixed;
622 check->corruptions_fixed = corruptions_fixed;
623 }
624
625 switch (output_format) {
626 case OFORMAT_HUMAN:
627 dump_human_image_check(check, quiet);
628 break;
629 case OFORMAT_JSON:
630 dump_json_image_check(check, quiet);
631 break;
632 }
633
634 if (ret || check->check_errors) {
635 ret = 1;
636 goto fail;
637 }
638
639 if (check->corruptions) {
640 ret = 2;
641 } else if (check->leaks) {
642 ret = 3;
643 } else {
644 ret = 0;
645 }
646
647 fail:
648 qapi_free_ImageCheck(check);
649 bdrv_delete(bs);
650
651 return ret;
652 }
653
654 static int img_commit(int argc, char **argv)
655 {
656 int c, ret, flags;
657 const char *filename, *fmt, *cache;
658 BlockDriverState *bs;
659 bool quiet = false;
660
661 fmt = NULL;
662 cache = BDRV_DEFAULT_CACHE;
663 for(;;) {
664 c = getopt(argc, argv, "f:ht:q");
665 if (c == -1) {
666 break;
667 }
668 switch(c) {
669 case '?':
670 case 'h':
671 help();
672 break;
673 case 'f':
674 fmt = optarg;
675 break;
676 case 't':
677 cache = optarg;
678 break;
679 case 'q':
680 quiet = true;
681 break;
682 }
683 }
684 if (optind >= argc) {
685 help();
686 }
687 filename = argv[optind++];
688
689 flags = BDRV_O_RDWR;
690 ret = bdrv_parse_cache_flags(cache, &flags);
691 if (ret < 0) {
692 error_report("Invalid cache option: %s", cache);
693 return -1;
694 }
695
696 bs = bdrv_new_open(filename, fmt, flags, true, quiet);
697 if (!bs) {
698 return 1;
699 }
700 ret = bdrv_commit(bs);
701 switch(ret) {
702 case 0:
703 qprintf(quiet, "Image committed.\n");
704 break;
705 case -ENOENT:
706 error_report("No disk inserted");
707 break;
708 case -EACCES:
709 error_report("Image is read-only");
710 break;
711 case -ENOTSUP:
712 error_report("Image is already committed");
713 break;
714 default:
715 error_report("Error while committing image");
716 break;
717 }
718
719 bdrv_delete(bs);
720 if (ret) {
721 return 1;
722 }
723 return 0;
724 }
725
726 /*
727 * Returns true iff the first sector pointed to by 'buf' contains at least
728 * a non-NUL byte.
729 *
730 * 'pnum' is set to the number of sectors (including and immediately following
731 * the first one) that are known to be in the same allocated/unallocated state.
732 */
733 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
734 {
735 bool is_zero;
736 int i;
737
738 if (n <= 0) {
739 *pnum = 0;
740 return 0;
741 }
742 is_zero = buffer_is_zero(buf, 512);
743 for(i = 1; i < n; i++) {
744 buf += 512;
745 if (is_zero != buffer_is_zero(buf, 512)) {
746 break;
747 }
748 }
749 *pnum = i;
750 return !is_zero;
751 }
752
753 /*
754 * Like is_allocated_sectors, but if the buffer starts with a used sector,
755 * up to 'min' consecutive sectors containing zeros are ignored. This avoids
756 * breaking up write requests for only small sparse areas.
757 */
758 static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
759 int min)
760 {
761 int ret;
762 int num_checked, num_used;
763
764 if (n < min) {
765 min = n;
766 }
767
768 ret = is_allocated_sectors(buf, n, pnum);
769 if (!ret) {
770 return ret;
771 }
772
773 num_used = *pnum;
774 buf += BDRV_SECTOR_SIZE * *pnum;
775 n -= *pnum;
776 num_checked = num_used;
777
778 while (n > 0) {
779 ret = is_allocated_sectors(buf, n, pnum);
780
781 buf += BDRV_SECTOR_SIZE * *pnum;
782 n -= *pnum;
783 num_checked += *pnum;
784 if (ret) {
785 num_used = num_checked;
786 } else if (*pnum >= min) {
787 break;
788 }
789 }
790
791 *pnum = num_used;
792 return 1;
793 }
794
795 /*
796 * Compares two buffers sector by sector. Returns 0 if the first sector of both
797 * buffers matches, non-zero otherwise.
798 *
799 * pnum is set to the number of sectors (including and immediately following
800 * the first one) that are known to have the same comparison result
801 */
802 static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
803 int *pnum)
804 {
805 int res, i;
806
807 if (n <= 0) {
808 *pnum = 0;
809 return 0;
810 }
811
812 res = !!memcmp(buf1, buf2, 512);
813 for(i = 1; i < n; i++) {
814 buf1 += 512;
815 buf2 += 512;
816
817 if (!!memcmp(buf1, buf2, 512) != res) {
818 break;
819 }
820 }
821
822 *pnum = i;
823 return res;
824 }
825
826 #define IO_BUF_SIZE (2 * 1024 * 1024)
827
828 static int64_t sectors_to_bytes(int64_t sectors)
829 {
830 return sectors << BDRV_SECTOR_BITS;
831 }
832
833 static int64_t sectors_to_process(int64_t total, int64_t from)
834 {
835 return MIN(total - from, IO_BUF_SIZE >> BDRV_SECTOR_BITS);
836 }
837
838 /*
839 * Check if passed sectors are empty (not allocated or contain only 0 bytes)
840 *
841 * Returns 0 in case sectors are filled with 0, 1 if sectors contain non-zero
842 * data and negative value on error.
843 *
844 * @param bs: Driver used for accessing file
845 * @param sect_num: Number of first sector to check
846 * @param sect_count: Number of sectors to check
847 * @param filename: Name of disk file we are checking (logging purpose)
848 * @param buffer: Allocated buffer for storing read data
849 * @param quiet: Flag for quiet mode
850 */
851 static int check_empty_sectors(BlockDriverState *bs, int64_t sect_num,
852 int sect_count, const char *filename,
853 uint8_t *buffer, bool quiet)
854 {
855 int pnum, ret = 0;
856 ret = bdrv_read(bs, sect_num, buffer, sect_count);
857 if (ret < 0) {
858 error_report("Error while reading offset %" PRId64 " of %s: %s",
859 sectors_to_bytes(sect_num), filename, strerror(-ret));
860 return ret;
861 }
862 ret = is_allocated_sectors(buffer, sect_count, &pnum);
863 if (ret || pnum != sect_count) {
864 qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
865 sectors_to_bytes(ret ? sect_num : sect_num + pnum));
866 return 1;
867 }
868
869 return 0;
870 }
871
872 /*
873 * Compares two images. Exit codes:
874 *
875 * 0 - Images are identical
876 * 1 - Images differ
877 * >1 - Error occurred
878 */
879 static int img_compare(int argc, char **argv)
880 {
881 const char *fmt1 = NULL, *fmt2 = NULL, *filename1, *filename2;
882 BlockDriverState *bs1, *bs2;
883 int64_t total_sectors1, total_sectors2;
884 uint8_t *buf1 = NULL, *buf2 = NULL;
885 int pnum1, pnum2;
886 int allocated1, allocated2;
887 int ret = 0; /* return value - 0 Ident, 1 Different, >1 Error */
888 bool progress = false, quiet = false, strict = false;
889 int64_t total_sectors;
890 int64_t sector_num = 0;
891 int64_t nb_sectors;
892 int c, pnum;
893 uint64_t bs_sectors;
894 uint64_t progress_base;
895
896 for (;;) {
897 c = getopt(argc, argv, "hpf:F:sq");
898 if (c == -1) {
899 break;
900 }
901 switch (c) {
902 case '?':
903 case 'h':
904 help();
905 break;
906 case 'f':
907 fmt1 = optarg;
908 break;
909 case 'F':
910 fmt2 = optarg;
911 break;
912 case 'p':
913 progress = true;
914 break;
915 case 'q':
916 quiet = true;
917 break;
918 case 's':
919 strict = true;
920 break;
921 }
922 }
923
924 /* Progress is not shown in Quiet mode */
925 if (quiet) {
926 progress = false;
927 }
928
929
930 if (optind > argc - 2) {
931 help();
932 }
933 filename1 = argv[optind++];
934 filename2 = argv[optind++];
935
936 /* Initialize before goto out */
937 qemu_progress_init(progress, 2.0);
938
939 bs1 = bdrv_new_open(filename1, fmt1, BDRV_O_FLAGS, true, quiet);
940 if (!bs1) {
941 error_report("Can't open file %s", filename1);
942 ret = 2;
943 goto out3;
944 }
945
946 bs2 = bdrv_new_open(filename2, fmt2, BDRV_O_FLAGS, true, quiet);
947 if (!bs2) {
948 error_report("Can't open file %s", filename2);
949 ret = 2;
950 goto out2;
951 }
952
953 buf1 = qemu_blockalign(bs1, IO_BUF_SIZE);
954 buf2 = qemu_blockalign(bs2, IO_BUF_SIZE);
955 bdrv_get_geometry(bs1, &bs_sectors);
956 total_sectors1 = bs_sectors;
957 bdrv_get_geometry(bs2, &bs_sectors);
958 total_sectors2 = bs_sectors;
959 total_sectors = MIN(total_sectors1, total_sectors2);
960 progress_base = MAX(total_sectors1, total_sectors2);
961
962 qemu_progress_print(0, 100);
963
964 if (strict && total_sectors1 != total_sectors2) {
965 ret = 1;
966 qprintf(quiet, "Strict mode: Image size mismatch!\n");
967 goto out;
968 }
969
970 for (;;) {
971 nb_sectors = sectors_to_process(total_sectors, sector_num);
972 if (nb_sectors <= 0) {
973 break;
974 }
975 allocated1 = bdrv_is_allocated_above(bs1, NULL, sector_num, nb_sectors,
976 &pnum1);
977 if (allocated1 < 0) {
978 ret = 3;
979 error_report("Sector allocation test failed for %s", filename1);
980 goto out;
981 }
982
983 allocated2 = bdrv_is_allocated_above(bs2, NULL, sector_num, nb_sectors,
984 &pnum2);
985 if (allocated2 < 0) {
986 ret = 3;
987 error_report("Sector allocation test failed for %s", filename2);
988 goto out;
989 }
990 nb_sectors = MIN(pnum1, pnum2);
991
992 if (allocated1 == allocated2) {
993 if (allocated1) {
994 ret = bdrv_read(bs1, sector_num, buf1, nb_sectors);
995 if (ret < 0) {
996 error_report("Error while reading offset %" PRId64 " of %s:"
997 " %s", sectors_to_bytes(sector_num), filename1,
998 strerror(-ret));
999 ret = 4;
1000 goto out;
1001 }
1002 ret = bdrv_read(bs2, sector_num, buf2, nb_sectors);
1003 if (ret < 0) {
1004 error_report("Error while reading offset %" PRId64
1005 " of %s: %s", sectors_to_bytes(sector_num),
1006 filename2, strerror(-ret));
1007 ret = 4;
1008 goto out;
1009 }
1010 ret = compare_sectors(buf1, buf2, nb_sectors, &pnum);
1011 if (ret || pnum != nb_sectors) {
1012 ret = 1;
1013 qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
1014 sectors_to_bytes(
1015 ret ? sector_num : sector_num + pnum));
1016 goto out;
1017 }
1018 }
1019 } else {
1020 if (strict) {
1021 ret = 1;
1022 qprintf(quiet, "Strict mode: Offset %" PRId64
1023 " allocation mismatch!\n",
1024 sectors_to_bytes(sector_num));
1025 goto out;
1026 }
1027
1028 if (allocated1) {
1029 ret = check_empty_sectors(bs1, sector_num, nb_sectors,
1030 filename1, buf1, quiet);
1031 } else {
1032 ret = check_empty_sectors(bs2, sector_num, nb_sectors,
1033 filename2, buf1, quiet);
1034 }
1035 if (ret) {
1036 if (ret < 0) {
1037 ret = 4;
1038 error_report("Error while reading offset %" PRId64 ": %s",
1039 sectors_to_bytes(sector_num), strerror(-ret));
1040 }
1041 goto out;
1042 }
1043 }
1044 sector_num += nb_sectors;
1045 qemu_progress_print(((float) nb_sectors / progress_base)*100, 100);
1046 }
1047
1048 if (total_sectors1 != total_sectors2) {
1049 BlockDriverState *bs_over;
1050 int64_t total_sectors_over;
1051 const char *filename_over;
1052
1053 qprintf(quiet, "Warning: Image size mismatch!\n");
1054 if (total_sectors1 > total_sectors2) {
1055 total_sectors_over = total_sectors1;
1056 bs_over = bs1;
1057 filename_over = filename1;
1058 } else {
1059 total_sectors_over = total_sectors2;
1060 bs_over = bs2;
1061 filename_over = filename2;
1062 }
1063
1064 for (;;) {
1065 nb_sectors = sectors_to_process(total_sectors_over, sector_num);
1066 if (nb_sectors <= 0) {
1067 break;
1068 }
1069 ret = bdrv_is_allocated_above(bs_over, NULL, sector_num,
1070 nb_sectors, &pnum);
1071 if (ret < 0) {
1072 ret = 3;
1073 error_report("Sector allocation test failed for %s",
1074 filename_over);
1075 goto out;
1076
1077 }
1078 nb_sectors = pnum;
1079 if (ret) {
1080 ret = check_empty_sectors(bs_over, sector_num, nb_sectors,
1081 filename_over, buf1, quiet);
1082 if (ret) {
1083 if (ret < 0) {
1084 ret = 4;
1085 error_report("Error while reading offset %" PRId64
1086 " of %s: %s", sectors_to_bytes(sector_num),
1087 filename_over, strerror(-ret));
1088 }
1089 goto out;
1090 }
1091 }
1092 sector_num += nb_sectors;
1093 qemu_progress_print(((float) nb_sectors / progress_base)*100, 100);
1094 }
1095 }
1096
1097 qprintf(quiet, "Images are identical.\n");
1098 ret = 0;
1099
1100 out:
1101 bdrv_delete(bs2);
1102 qemu_vfree(buf1);
1103 qemu_vfree(buf2);
1104 out2:
1105 bdrv_delete(bs1);
1106 out3:
1107 qemu_progress_end();
1108 return ret;
1109 }
1110
1111 static int img_convert(int argc, char **argv)
1112 {
1113 int c, ret = 0, n, n1, bs_n, bs_i, compress, cluster_size, cluster_sectors;
1114 int progress = 0, flags;
1115 const char *fmt, *out_fmt, *cache, *out_baseimg, *out_filename;
1116 BlockDriver *drv, *proto_drv;
1117 BlockDriverState **bs = NULL, *out_bs = NULL;
1118 int64_t total_sectors, nb_sectors, sector_num, bs_offset;
1119 uint64_t bs_sectors;
1120 uint8_t * buf = NULL;
1121 const uint8_t *buf1;
1122 BlockDriverInfo bdi;
1123 QEMUOptionParameter *param = NULL, *create_options = NULL;
1124 QEMUOptionParameter *out_baseimg_param;
1125 char *options = NULL;
1126 const char *snapshot_name = NULL;
1127 float local_progress = 0;
1128 int min_sparse = 8; /* Need at least 4k of zeros for sparse detection */
1129 bool quiet = false;
1130
1131 fmt = NULL;
1132 out_fmt = "raw";
1133 cache = "unsafe";
1134 out_baseimg = NULL;
1135 compress = 0;
1136 for(;;) {
1137 c = getopt(argc, argv, "f:O:B:s:hce6o:pS:t:q");
1138 if (c == -1) {
1139 break;
1140 }
1141 switch(c) {
1142 case '?':
1143 case 'h':
1144 help();
1145 break;
1146 case 'f':
1147 fmt = optarg;
1148 break;
1149 case 'O':
1150 out_fmt = optarg;
1151 break;
1152 case 'B':
1153 out_baseimg = optarg;
1154 break;
1155 case 'c':
1156 compress = 1;
1157 break;
1158 case 'e':
1159 error_report("option -e is deprecated, please use \'-o "
1160 "encryption\' instead!");
1161 return 1;
1162 case '6':
1163 error_report("option -6 is deprecated, please use \'-o "
1164 "compat6\' instead!");
1165 return 1;
1166 case 'o':
1167 options = optarg;
1168 break;
1169 case 's':
1170 snapshot_name = optarg;
1171 break;
1172 case 'S':
1173 {
1174 int64_t sval;
1175 char *end;
1176 sval = strtosz_suffix(optarg, &end, STRTOSZ_DEFSUFFIX_B);
1177 if (sval < 0 || *end) {
1178 error_report("Invalid minimum zero buffer size for sparse output specified");
1179 return 1;
1180 }
1181
1182 min_sparse = sval / BDRV_SECTOR_SIZE;
1183 break;
1184 }
1185 case 'p':
1186 progress = 1;
1187 break;
1188 case 't':
1189 cache = optarg;
1190 break;
1191 case 'q':
1192 quiet = true;
1193 break;
1194 }
1195 }
1196
1197 if (quiet) {
1198 progress = 0;
1199 }
1200
1201 bs_n = argc - optind - 1;
1202 if (bs_n < 1) {
1203 help();
1204 }
1205
1206 out_filename = argv[argc - 1];
1207
1208 /* Initialize before goto out */
1209 qemu_progress_init(progress, 2.0);
1210
1211 if (options && is_help_option(options)) {
1212 ret = print_block_option_help(out_filename, out_fmt);
1213 goto out;
1214 }
1215
1216 if (bs_n > 1 && out_baseimg) {
1217 error_report("-B makes no sense when concatenating multiple input "
1218 "images");
1219 ret = -1;
1220 goto out;
1221 }
1222
1223 qemu_progress_print(0, 100);
1224
1225 bs = g_malloc0(bs_n * sizeof(BlockDriverState *));
1226
1227 total_sectors = 0;
1228 for (bs_i = 0; bs_i < bs_n; bs_i++) {
1229 bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, BDRV_O_FLAGS, true,
1230 quiet);
1231 if (!bs[bs_i]) {
1232 error_report("Could not open '%s'", argv[optind + bs_i]);
1233 ret = -1;
1234 goto out;
1235 }
1236 bdrv_get_geometry(bs[bs_i], &bs_sectors);
1237 total_sectors += bs_sectors;
1238 }
1239
1240 if (snapshot_name != NULL) {
1241 if (bs_n > 1) {
1242 error_report("No support for concatenating multiple snapshot");
1243 ret = -1;
1244 goto out;
1245 }
1246 if (bdrv_snapshot_load_tmp(bs[0], snapshot_name) < 0) {
1247 error_report("Failed to load snapshot");
1248 ret = -1;
1249 goto out;
1250 }
1251 }
1252
1253 /* Find driver and parse its options */
1254 drv = bdrv_find_format(out_fmt);
1255 if (!drv) {
1256 error_report("Unknown file format '%s'", out_fmt);
1257 ret = -1;
1258 goto out;
1259 }
1260
1261 proto_drv = bdrv_find_protocol(out_filename);
1262 if (!proto_drv) {
1263 error_report("Unknown protocol '%s'", out_filename);
1264 ret = -1;
1265 goto out;
1266 }
1267
1268 create_options = append_option_parameters(create_options,
1269 drv->create_options);
1270 create_options = append_option_parameters(create_options,
1271 proto_drv->create_options);
1272
1273 if (options) {
1274 param = parse_option_parameters(options, create_options, param);
1275 if (param == NULL) {
1276 error_report("Invalid options for file format '%s'.", out_fmt);
1277 ret = -1;
1278 goto out;
1279 }
1280 } else {
1281 param = parse_option_parameters("", create_options, param);
1282 }
1283
1284 set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
1285 ret = add_old_style_options(out_fmt, param, out_baseimg, NULL);
1286 if (ret < 0) {
1287 goto out;
1288 }
1289
1290 /* Get backing file name if -o backing_file was used */
1291 out_baseimg_param = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
1292 if (out_baseimg_param) {
1293 out_baseimg = out_baseimg_param->value.s;
1294 }
1295
1296 /* Check if compression is supported */
1297 if (compress) {
1298 QEMUOptionParameter *encryption =
1299 get_option_parameter(param, BLOCK_OPT_ENCRYPT);
1300 QEMUOptionParameter *preallocation =
1301 get_option_parameter(param, BLOCK_OPT_PREALLOC);
1302
1303 if (!drv->bdrv_write_compressed) {
1304 error_report("Compression not supported for this file format");
1305 ret = -1;
1306 goto out;
1307 }
1308
1309 if (encryption && encryption->value.n) {
1310 error_report("Compression and encryption not supported at "
1311 "the same time");
1312 ret = -1;
1313 goto out;
1314 }
1315
1316 if (preallocation && preallocation->value.s
1317 && strcmp(preallocation->value.s, "off"))
1318 {
1319 error_report("Compression and preallocation not supported at "
1320 "the same time");
1321 ret = -1;
1322 goto out;
1323 }
1324 }
1325
1326 /* Create the new image */
1327 ret = bdrv_create(drv, out_filename, param);
1328 if (ret < 0) {
1329 if (ret == -ENOTSUP) {
1330 error_report("Formatting not supported for file format '%s'",
1331 out_fmt);
1332 } else if (ret == -EFBIG) {
1333 error_report("The image size is too large for file format '%s'",
1334 out_fmt);
1335 } else {
1336 error_report("%s: error while converting %s: %s",
1337 out_filename, out_fmt, strerror(-ret));
1338 }
1339 goto out;
1340 }
1341
1342 flags = BDRV_O_RDWR;
1343 ret = bdrv_parse_cache_flags(cache, &flags);
1344 if (ret < 0) {
1345 error_report("Invalid cache option: %s", cache);
1346 return -1;
1347 }
1348
1349 out_bs = bdrv_new_open(out_filename, out_fmt, flags, true, quiet);
1350 if (!out_bs) {
1351 ret = -1;
1352 goto out;
1353 }
1354
1355 bs_i = 0;
1356 bs_offset = 0;
1357 bdrv_get_geometry(bs[0], &bs_sectors);
1358 buf = qemu_blockalign(out_bs, IO_BUF_SIZE);
1359
1360 if (compress) {
1361 ret = bdrv_get_info(out_bs, &bdi);
1362 if (ret < 0) {
1363 error_report("could not get block driver info");
1364 goto out;
1365 }
1366 cluster_size = bdi.cluster_size;
1367 if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) {
1368 error_report("invalid cluster size");
1369 ret = -1;
1370 goto out;
1371 }
1372 cluster_sectors = cluster_size >> 9;
1373 sector_num = 0;
1374
1375 nb_sectors = total_sectors;
1376 if (nb_sectors != 0) {
1377 local_progress = (float)100 /
1378 (nb_sectors / MIN(nb_sectors, cluster_sectors));
1379 }
1380
1381 for(;;) {
1382 int64_t bs_num;
1383 int remainder;
1384 uint8_t *buf2;
1385
1386 nb_sectors = total_sectors - sector_num;
1387 if (nb_sectors <= 0)
1388 break;
1389 if (nb_sectors >= cluster_sectors)
1390 n = cluster_sectors;
1391 else
1392 n = nb_sectors;
1393
1394 bs_num = sector_num - bs_offset;
1395 assert (bs_num >= 0);
1396 remainder = n;
1397 buf2 = buf;
1398 while (remainder > 0) {
1399 int nlow;
1400 while (bs_num == bs_sectors) {
1401 bs_i++;
1402 assert (bs_i < bs_n);
1403 bs_offset += bs_sectors;
1404 bdrv_get_geometry(bs[bs_i], &bs_sectors);
1405 bs_num = 0;
1406 /* printf("changing part: sector_num=%" PRId64 ", "
1407 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
1408 "\n", sector_num, bs_i, bs_offset, bs_sectors); */
1409 }
1410 assert (bs_num < bs_sectors);
1411
1412 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;
1413
1414 ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow);
1415 if (ret < 0) {
1416 error_report("error while reading sector %" PRId64 ": %s",
1417 bs_num, strerror(-ret));
1418 goto out;
1419 }
1420
1421 buf2 += nlow * 512;
1422 bs_num += nlow;
1423
1424 remainder -= nlow;
1425 }
1426 assert (remainder == 0);
1427
1428 if (!buffer_is_zero(buf, n * BDRV_SECTOR_SIZE)) {
1429 ret = bdrv_write_compressed(out_bs, sector_num, buf, n);
1430 if (ret != 0) {
1431 error_report("error while compressing sector %" PRId64
1432 ": %s", sector_num, strerror(-ret));
1433 goto out;
1434 }
1435 }
1436 sector_num += n;
1437 qemu_progress_print(local_progress, 100);
1438 }
1439 /* signal EOF to align */
1440 bdrv_write_compressed(out_bs, 0, NULL, 0);
1441 } else {
1442 int has_zero_init = bdrv_has_zero_init(out_bs);
1443
1444 sector_num = 0; // total number of sectors converted so far
1445 nb_sectors = total_sectors - sector_num;
1446 if (nb_sectors != 0) {
1447 local_progress = (float)100 /
1448 (nb_sectors / MIN(nb_sectors, IO_BUF_SIZE / 512));
1449 }
1450
1451 for(;;) {
1452 nb_sectors = total_sectors - sector_num;
1453 if (nb_sectors <= 0) {
1454 break;
1455 }
1456 if (nb_sectors >= (IO_BUF_SIZE / 512)) {
1457 n = (IO_BUF_SIZE / 512);
1458 } else {
1459 n = nb_sectors;
1460 }
1461
1462 while (sector_num - bs_offset >= bs_sectors) {
1463 bs_i ++;
1464 assert (bs_i < bs_n);
1465 bs_offset += bs_sectors;
1466 bdrv_get_geometry(bs[bs_i], &bs_sectors);
1467 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
1468 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
1469 sector_num, bs_i, bs_offset, bs_sectors); */
1470 }
1471
1472 if (n > bs_offset + bs_sectors - sector_num) {
1473 n = bs_offset + bs_sectors - sector_num;
1474 }
1475
1476 if (has_zero_init) {
1477 /* If the output image is being created as a copy on write image,
1478 assume that sectors which are unallocated in the input image
1479 are present in both the output's and input's base images (no
1480 need to copy them). */
1481 if (out_baseimg) {
1482 if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
1483 n, &n1)) {
1484 sector_num += n1;
1485 continue;
1486 }
1487 /* The next 'n1' sectors are allocated in the input image. Copy
1488 only those as they may be followed by unallocated sectors. */
1489 n = n1;
1490 }
1491 } else {
1492 n1 = n;
1493 }
1494
1495 ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
1496 if (ret < 0) {
1497 error_report("error while reading sector %" PRId64 ": %s",
1498 sector_num - bs_offset, strerror(-ret));
1499 goto out;
1500 }
1501 /* NOTE: at the same time we convert, we do not write zero
1502 sectors to have a chance to compress the image. Ideally, we
1503 should add a specific call to have the info to go faster */
1504 buf1 = buf;
1505 while (n > 0) {
1506 /* If the output image is being created as a copy on write image,
1507 copy all sectors even the ones containing only NUL bytes,
1508 because they may differ from the sectors in the base image.
1509
1510 If the output is to a host device, we also write out
1511 sectors that are entirely 0, since whatever data was
1512 already there is garbage, not 0s. */
1513 if (!has_zero_init || out_baseimg ||
1514 is_allocated_sectors_min(buf1, n, &n1, min_sparse)) {
1515 ret = bdrv_write(out_bs, sector_num, buf1, n1);
1516 if (ret < 0) {
1517 error_report("error while writing sector %" PRId64
1518 ": %s", sector_num, strerror(-ret));
1519 goto out;
1520 }
1521 }
1522 sector_num += n1;
1523 n -= n1;
1524 buf1 += n1 * 512;
1525 }
1526 qemu_progress_print(local_progress, 100);
1527 }
1528 }
1529 out:
1530 qemu_progress_end();
1531 free_option_parameters(create_options);
1532 free_option_parameters(param);
1533 qemu_vfree(buf);
1534 if (out_bs) {
1535 bdrv_delete(out_bs);
1536 }
1537 if (bs) {
1538 for (bs_i = 0; bs_i < bs_n; bs_i++) {
1539 if (bs[bs_i]) {
1540 bdrv_delete(bs[bs_i]);
1541 }
1542 }
1543 g_free(bs);
1544 }
1545 if (ret) {
1546 return 1;
1547 }
1548 return 0;
1549 }
1550
1551
1552 static void dump_snapshots(BlockDriverState *bs)
1553 {
1554 QEMUSnapshotInfo *sn_tab, *sn;
1555 int nb_sns, i;
1556 char buf[256];
1557
1558 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1559 if (nb_sns <= 0)
1560 return;
1561 printf("Snapshot list:\n");
1562 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
1563 for(i = 0; i < nb_sns; i++) {
1564 sn = &sn_tab[i];
1565 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
1566 }
1567 g_free(sn_tab);
1568 }
1569
1570 static void dump_json_image_info_list(ImageInfoList *list)
1571 {
1572 Error *errp = NULL;
1573 QString *str;
1574 QmpOutputVisitor *ov = qmp_output_visitor_new();
1575 QObject *obj;
1576 visit_type_ImageInfoList(qmp_output_get_visitor(ov),
1577 &list, NULL, &errp);
1578 obj = qmp_output_get_qobject(ov);
1579 str = qobject_to_json_pretty(obj);
1580 assert(str != NULL);
1581 printf("%s\n", qstring_get_str(str));
1582 qobject_decref(obj);
1583 qmp_output_visitor_cleanup(ov);
1584 QDECREF(str);
1585 }
1586
1587 static void collect_snapshots(BlockDriverState *bs , ImageInfo *info)
1588 {
1589 int i, sn_count;
1590 QEMUSnapshotInfo *sn_tab = NULL;
1591 SnapshotInfoList *info_list, *cur_item = NULL;
1592 sn_count = bdrv_snapshot_list(bs, &sn_tab);
1593
1594 for (i = 0; i < sn_count; i++) {
1595 info->has_snapshots = true;
1596 info_list = g_new0(SnapshotInfoList, 1);
1597
1598 info_list->value = g_new0(SnapshotInfo, 1);
1599 info_list->value->id = g_strdup(sn_tab[i].id_str);
1600 info_list->value->name = g_strdup(sn_tab[i].name);
1601 info_list->value->vm_state_size = sn_tab[i].vm_state_size;
1602 info_list->value->date_sec = sn_tab[i].date_sec;
1603 info_list->value->date_nsec = sn_tab[i].date_nsec;
1604 info_list->value->vm_clock_sec = sn_tab[i].vm_clock_nsec / 1000000000;
1605 info_list->value->vm_clock_nsec = sn_tab[i].vm_clock_nsec % 1000000000;
1606
1607 /* XXX: waiting for the qapi to support qemu-queue.h types */
1608 if (!cur_item) {
1609 info->snapshots = cur_item = info_list;
1610 } else {
1611 cur_item->next = info_list;
1612 cur_item = info_list;
1613 }
1614
1615 }
1616
1617 g_free(sn_tab);
1618 }
1619
1620 static void dump_json_image_info(ImageInfo *info)
1621 {
1622 Error *errp = NULL;
1623 QString *str;
1624 QmpOutputVisitor *ov = qmp_output_visitor_new();
1625 QObject *obj;
1626 visit_type_ImageInfo(qmp_output_get_visitor(ov),
1627 &info, NULL, &errp);
1628 obj = qmp_output_get_qobject(ov);
1629 str = qobject_to_json_pretty(obj);
1630 assert(str != NULL);
1631 printf("%s\n", qstring_get_str(str));
1632 qobject_decref(obj);
1633 qmp_output_visitor_cleanup(ov);
1634 QDECREF(str);
1635 }
1636
1637 static void collect_image_info(BlockDriverState *bs,
1638 ImageInfo *info,
1639 const char *filename,
1640 const char *fmt)
1641 {
1642 uint64_t total_sectors;
1643 char backing_filename[1024];
1644 char backing_filename2[1024];
1645 BlockDriverInfo bdi;
1646
1647 bdrv_get_geometry(bs, &total_sectors);
1648
1649 info->filename = g_strdup(filename);
1650 info->format = g_strdup(bdrv_get_format_name(bs));
1651 info->virtual_size = total_sectors * 512;
1652 info->actual_size = bdrv_get_allocated_file_size(bs);
1653 info->has_actual_size = info->actual_size >= 0;
1654 if (bdrv_is_encrypted(bs)) {
1655 info->encrypted = true;
1656 info->has_encrypted = true;
1657 }
1658 if (bdrv_get_info(bs, &bdi) >= 0) {
1659 if (bdi.cluster_size != 0) {
1660 info->cluster_size = bdi.cluster_size;
1661 info->has_cluster_size = true;
1662 }
1663 info->dirty_flag = bdi.is_dirty;
1664 info->has_dirty_flag = true;
1665 }
1666 bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
1667 if (backing_filename[0] != '\0') {
1668 info->backing_filename = g_strdup(backing_filename);
1669 info->has_backing_filename = true;
1670 bdrv_get_full_backing_filename(bs, backing_filename2,
1671 sizeof(backing_filename2));
1672
1673 if (strcmp(backing_filename, backing_filename2) != 0) {
1674 info->full_backing_filename =
1675 g_strdup(backing_filename2);
1676 info->has_full_backing_filename = true;
1677 }
1678
1679 if (bs->backing_format[0]) {
1680 info->backing_filename_format = g_strdup(bs->backing_format);
1681 info->has_backing_filename_format = true;
1682 }
1683 }
1684 }
1685
1686 static void dump_human_image_info(ImageInfo *info)
1687 {
1688 char size_buf[128], dsize_buf[128];
1689 if (!info->has_actual_size) {
1690 snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
1691 } else {
1692 get_human_readable_size(dsize_buf, sizeof(dsize_buf),
1693 info->actual_size);
1694 }
1695 get_human_readable_size(size_buf, sizeof(size_buf), info->virtual_size);
1696 printf("image: %s\n"
1697 "file format: %s\n"
1698 "virtual size: %s (%" PRId64 " bytes)\n"
1699 "disk size: %s\n",
1700 info->filename, info->format, size_buf,
1701 info->virtual_size,
1702 dsize_buf);
1703
1704 if (info->has_encrypted && info->encrypted) {
1705 printf("encrypted: yes\n");
1706 }
1707
1708 if (info->has_cluster_size) {
1709 printf("cluster_size: %" PRId64 "\n", info->cluster_size);
1710 }
1711
1712 if (info->has_dirty_flag && info->dirty_flag) {
1713 printf("cleanly shut down: no\n");
1714 }
1715
1716 if (info->has_backing_filename) {
1717 printf("backing file: %s", info->backing_filename);
1718 if (info->has_full_backing_filename) {
1719 printf(" (actual path: %s)", info->full_backing_filename);
1720 }
1721 putchar('\n');
1722 if (info->has_backing_filename_format) {
1723 printf("backing file format: %s\n", info->backing_filename_format);
1724 }
1725 }
1726
1727 if (info->has_snapshots) {
1728 SnapshotInfoList *elem;
1729 char buf[256];
1730
1731 printf("Snapshot list:\n");
1732 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
1733
1734 /* Ideally bdrv_snapshot_dump() would operate on SnapshotInfoList but
1735 * we convert to the block layer's native QEMUSnapshotInfo for now.
1736 */
1737 for (elem = info->snapshots; elem; elem = elem->next) {
1738 QEMUSnapshotInfo sn = {
1739 .vm_state_size = elem->value->vm_state_size,
1740 .date_sec = elem->value->date_sec,
1741 .date_nsec = elem->value->date_nsec,
1742 .vm_clock_nsec = elem->value->vm_clock_sec * 1000000000ULL +
1743 elem->value->vm_clock_nsec,
1744 };
1745
1746 pstrcpy(sn.id_str, sizeof(sn.id_str), elem->value->id);
1747 pstrcpy(sn.name, sizeof(sn.name), elem->value->name);
1748 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), &sn));
1749 }
1750 }
1751 }
1752
1753 static void dump_human_image_info_list(ImageInfoList *list)
1754 {
1755 ImageInfoList *elem;
1756 bool delim = false;
1757
1758 for (elem = list; elem; elem = elem->next) {
1759 if (delim) {
1760 printf("\n");
1761 }
1762 delim = true;
1763
1764 dump_human_image_info(elem->value);
1765 }
1766 }
1767
1768 static gboolean str_equal_func(gconstpointer a, gconstpointer b)
1769 {
1770 return strcmp(a, b) == 0;
1771 }
1772
1773 /**
1774 * Open an image file chain and return an ImageInfoList
1775 *
1776 * @filename: topmost image filename
1777 * @fmt: topmost image format (may be NULL to autodetect)
1778 * @chain: true - enumerate entire backing file chain
1779 * false - only topmost image file
1780 *
1781 * Returns a list of ImageInfo objects or NULL if there was an error opening an
1782 * image file. If there was an error a message will have been printed to
1783 * stderr.
1784 */
1785 static ImageInfoList *collect_image_info_list(const char *filename,
1786 const char *fmt,
1787 bool chain)
1788 {
1789 ImageInfoList *head = NULL;
1790 ImageInfoList **last = &head;
1791 GHashTable *filenames;
1792
1793 filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL);
1794
1795 while (filename) {
1796 BlockDriverState *bs;
1797 ImageInfo *info;
1798 ImageInfoList *elem;
1799
1800 if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) {
1801 error_report("Backing file '%s' creates an infinite loop.",
1802 filename);
1803 goto err;
1804 }
1805 g_hash_table_insert(filenames, (gpointer)filename, NULL);
1806
1807 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING,
1808 false, false);
1809 if (!bs) {
1810 goto err;
1811 }
1812
1813 info = g_new0(ImageInfo, 1);
1814 collect_image_info(bs, info, filename, fmt);
1815 collect_snapshots(bs, info);
1816
1817 elem = g_new0(ImageInfoList, 1);
1818 elem->value = info;
1819 *last = elem;
1820 last = &elem->next;
1821
1822 bdrv_delete(bs);
1823
1824 filename = fmt = NULL;
1825 if (chain) {
1826 if (info->has_full_backing_filename) {
1827 filename = info->full_backing_filename;
1828 } else if (info->has_backing_filename) {
1829 filename = info->backing_filename;
1830 }
1831 if (info->has_backing_filename_format) {
1832 fmt = info->backing_filename_format;
1833 }
1834 }
1835 }
1836 g_hash_table_destroy(filenames);
1837 return head;
1838
1839 err:
1840 qapi_free_ImageInfoList(head);
1841 g_hash_table_destroy(filenames);
1842 return NULL;
1843 }
1844
1845 static int img_info(int argc, char **argv)
1846 {
1847 int c;
1848 OutputFormat output_format = OFORMAT_HUMAN;
1849 bool chain = false;
1850 const char *filename, *fmt, *output;
1851 ImageInfoList *list;
1852
1853 fmt = NULL;
1854 output = NULL;
1855 for(;;) {
1856 int option_index = 0;
1857 static const struct option long_options[] = {
1858 {"help", no_argument, 0, 'h'},
1859 {"format", required_argument, 0, 'f'},
1860 {"output", required_argument, 0, OPTION_OUTPUT},
1861 {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN},
1862 {0, 0, 0, 0}
1863 };
1864 c = getopt_long(argc, argv, "f:h",
1865 long_options, &option_index);
1866 if (c == -1) {
1867 break;
1868 }
1869 switch(c) {
1870 case '?':
1871 case 'h':
1872 help();
1873 break;
1874 case 'f':
1875 fmt = optarg;
1876 break;
1877 case OPTION_OUTPUT:
1878 output = optarg;
1879 break;
1880 case OPTION_BACKING_CHAIN:
1881 chain = true;
1882 break;
1883 }
1884 }
1885 if (optind >= argc) {
1886 help();
1887 }
1888 filename = argv[optind++];
1889
1890 if (output && !strcmp(output, "json")) {
1891 output_format = OFORMAT_JSON;
1892 } else if (output && !strcmp(output, "human")) {
1893 output_format = OFORMAT_HUMAN;
1894 } else if (output) {
1895 error_report("--output must be used with human or json as argument.");
1896 return 1;
1897 }
1898
1899 list = collect_image_info_list(filename, fmt, chain);
1900 if (!list) {
1901 return 1;
1902 }
1903
1904 switch (output_format) {
1905 case OFORMAT_HUMAN:
1906 dump_human_image_info_list(list);
1907 break;
1908 case OFORMAT_JSON:
1909 if (chain) {
1910 dump_json_image_info_list(list);
1911 } else {
1912 dump_json_image_info(list->value);
1913 }
1914 break;
1915 }
1916
1917 qapi_free_ImageInfoList(list);
1918 return 0;
1919 }
1920
1921 #define SNAPSHOT_LIST 1
1922 #define SNAPSHOT_CREATE 2
1923 #define SNAPSHOT_APPLY 3
1924 #define SNAPSHOT_DELETE 4
1925
1926 static int img_snapshot(int argc, char **argv)
1927 {
1928 BlockDriverState *bs;
1929 QEMUSnapshotInfo sn;
1930 char *filename, *snapshot_name = NULL;
1931 int c, ret = 0, bdrv_oflags;
1932 int action = 0;
1933 qemu_timeval tv;
1934 bool quiet = false;
1935
1936 bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
1937 /* Parse commandline parameters */
1938 for(;;) {
1939 c = getopt(argc, argv, "la:c:d:hq");
1940 if (c == -1) {
1941 break;
1942 }
1943 switch(c) {
1944 case '?':
1945 case 'h':
1946 help();
1947 return 0;
1948 case 'l':
1949 if (action) {
1950 help();
1951 return 0;
1952 }
1953 action = SNAPSHOT_LIST;
1954 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
1955 break;
1956 case 'a':
1957 if (action) {
1958 help();
1959 return 0;
1960 }
1961 action = SNAPSHOT_APPLY;
1962 snapshot_name = optarg;
1963 break;
1964 case 'c':
1965 if (action) {
1966 help();
1967 return 0;
1968 }
1969 action = SNAPSHOT_CREATE;
1970 snapshot_name = optarg;
1971 break;
1972 case 'd':
1973 if (action) {
1974 help();
1975 return 0;
1976 }
1977 action = SNAPSHOT_DELETE;
1978 snapshot_name = optarg;
1979 break;
1980 case 'q':
1981 quiet = true;
1982 break;
1983 }
1984 }
1985
1986 if (optind >= argc) {
1987 help();
1988 }
1989 filename = argv[optind++];
1990
1991 /* Open the image */
1992 bs = bdrv_new_open(filename, NULL, bdrv_oflags, true, quiet);
1993 if (!bs) {
1994 return 1;
1995 }
1996
1997 /* Perform the requested action */
1998 switch(action) {
1999 case SNAPSHOT_LIST:
2000 dump_snapshots(bs);
2001 break;
2002
2003 case SNAPSHOT_CREATE:
2004 memset(&sn, 0, sizeof(sn));
2005 pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
2006
2007 qemu_gettimeofday(&tv);
2008 sn.date_sec = tv.tv_sec;
2009 sn.date_nsec = tv.tv_usec * 1000;
2010
2011 ret = bdrv_snapshot_create(bs, &sn);
2012 if (ret) {
2013 error_report("Could not create snapshot '%s': %d (%s)",
2014 snapshot_name, ret, strerror(-ret));
2015 }
2016 break;
2017
2018 case SNAPSHOT_APPLY:
2019 ret = bdrv_snapshot_goto(bs, snapshot_name);
2020 if (ret) {
2021 error_report("Could not apply snapshot '%s': %d (%s)",
2022 snapshot_name, ret, strerror(-ret));
2023 }
2024 break;
2025
2026 case SNAPSHOT_DELETE:
2027 ret = bdrv_snapshot_delete(bs, snapshot_name);
2028 if (ret) {
2029 error_report("Could not delete snapshot '%s': %d (%s)",
2030 snapshot_name, ret, strerror(-ret));
2031 }
2032 break;
2033 }
2034
2035 /* Cleanup */
2036 bdrv_delete(bs);
2037 if (ret) {
2038 return 1;
2039 }
2040 return 0;
2041 }
2042
2043 static int img_rebase(int argc, char **argv)
2044 {
2045 BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
2046 BlockDriver *old_backing_drv, *new_backing_drv;
2047 char *filename;
2048 const char *fmt, *cache, *out_basefmt, *out_baseimg;
2049 int c, flags, ret;
2050 int unsafe = 0;
2051 int progress = 0;
2052 bool quiet = false;
2053
2054 /* Parse commandline parameters */
2055 fmt = NULL;
2056 cache = BDRV_DEFAULT_CACHE;
2057 out_baseimg = NULL;
2058 out_basefmt = NULL;
2059 for(;;) {
2060 c = getopt(argc, argv, "uhf:F:b:pt:q");
2061 if (c == -1) {
2062 break;
2063 }
2064 switch(c) {
2065 case '?':
2066 case 'h':
2067 help();
2068 return 0;
2069 case 'f':
2070 fmt = optarg;
2071 break;
2072 case 'F':
2073 out_basefmt = optarg;
2074 break;
2075 case 'b':
2076 out_baseimg = optarg;
2077 break;
2078 case 'u':
2079 unsafe = 1;
2080 break;
2081 case 'p':
2082 progress = 1;
2083 break;
2084 case 't':
2085 cache = optarg;
2086 break;
2087 case 'q':
2088 quiet = true;
2089 break;
2090 }
2091 }
2092
2093 if (quiet) {
2094 progress = 0;
2095 }
2096
2097 if ((optind >= argc) || (!unsafe && !out_baseimg)) {
2098 help();
2099 }
2100 filename = argv[optind++];
2101
2102 qemu_progress_init(progress, 2.0);
2103 qemu_progress_print(0, 100);
2104
2105 flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
2106 ret = bdrv_parse_cache_flags(cache, &flags);
2107 if (ret < 0) {
2108 error_report("Invalid cache option: %s", cache);
2109 return -1;
2110 }
2111
2112 /*
2113 * Open the images.
2114 *
2115 * Ignore the old backing file for unsafe rebase in case we want to correct
2116 * the reference to a renamed or moved backing file.
2117 */
2118 bs = bdrv_new_open(filename, fmt, flags, true, quiet);
2119 if (!bs) {
2120 return 1;
2121 }
2122
2123 /* Find the right drivers for the backing files */
2124 old_backing_drv = NULL;
2125 new_backing_drv = NULL;
2126
2127 if (!unsafe && bs->backing_format[0] != '\0') {
2128 old_backing_drv = bdrv_find_format(bs->backing_format);
2129 if (old_backing_drv == NULL) {
2130 error_report("Invalid format name: '%s'", bs->backing_format);
2131 ret = -1;
2132 goto out;
2133 }
2134 }
2135
2136 if (out_basefmt != NULL) {
2137 new_backing_drv = bdrv_find_format(out_basefmt);
2138 if (new_backing_drv == NULL) {
2139 error_report("Invalid format name: '%s'", out_basefmt);
2140 ret = -1;
2141 goto out;
2142 }
2143 }
2144
2145 /* For safe rebasing we need to compare old and new backing file */
2146 if (unsafe) {
2147 /* Make the compiler happy */
2148 bs_old_backing = NULL;
2149 bs_new_backing = NULL;
2150 } else {
2151 char backing_name[1024];
2152
2153 bs_old_backing = bdrv_new("old_backing");
2154 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
2155 ret = bdrv_open(bs_old_backing, backing_name, NULL, BDRV_O_FLAGS,
2156 old_backing_drv);
2157 if (ret) {
2158 error_report("Could not open old backing file '%s'", backing_name);
2159 goto out;
2160 }
2161 if (out_baseimg[0]) {
2162 bs_new_backing = bdrv_new("new_backing");
2163 ret = bdrv_open(bs_new_backing, out_baseimg, NULL, BDRV_O_FLAGS,
2164 new_backing_drv);
2165 if (ret) {
2166 error_report("Could not open new backing file '%s'",
2167 out_baseimg);
2168 goto out;
2169 }
2170 }
2171 }
2172
2173 /*
2174 * Check each unallocated cluster in the COW file. If it is unallocated,
2175 * accesses go to the backing file. We must therefore compare this cluster
2176 * in the old and new backing file, and if they differ we need to copy it
2177 * from the old backing file into the COW file.
2178 *
2179 * If qemu-img crashes during this step, no harm is done. The content of
2180 * the image is the same as the original one at any time.
2181 */
2182 if (!unsafe) {
2183 uint64_t num_sectors;
2184 uint64_t old_backing_num_sectors;
2185 uint64_t new_backing_num_sectors = 0;
2186 uint64_t sector;
2187 int n;
2188 uint8_t * buf_old;
2189 uint8_t * buf_new;
2190 float local_progress = 0;
2191
2192 buf_old = qemu_blockalign(bs, IO_BUF_SIZE);
2193 buf_new = qemu_blockalign(bs, IO_BUF_SIZE);
2194
2195 bdrv_get_geometry(bs, &num_sectors);
2196 bdrv_get_geometry(bs_old_backing, &old_backing_num_sectors);
2197 if (bs_new_backing) {
2198 bdrv_get_geometry(bs_new_backing, &new_backing_num_sectors);
2199 }
2200
2201 if (num_sectors != 0) {
2202 local_progress = (float)100 /
2203 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
2204 }
2205
2206 for (sector = 0; sector < num_sectors; sector += n) {
2207
2208 /* How many sectors can we handle with the next read? */
2209 if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
2210 n = (IO_BUF_SIZE / 512);
2211 } else {
2212 n = num_sectors - sector;
2213 }
2214
2215 /* If the cluster is allocated, we don't need to take action */
2216 ret = bdrv_is_allocated(bs, sector, n, &n);
2217 if (ret) {
2218 continue;
2219 }
2220
2221 /*
2222 * Read old and new backing file and take into consideration that
2223 * backing files may be smaller than the COW image.
2224 */
2225 if (sector >= old_backing_num_sectors) {
2226 memset(buf_old, 0, n * BDRV_SECTOR_SIZE);
2227 } else {
2228 if (sector + n > old_backing_num_sectors) {
2229 n = old_backing_num_sectors - sector;
2230 }
2231
2232 ret = bdrv_read(bs_old_backing, sector, buf_old, n);
2233 if (ret < 0) {
2234 error_report("error while reading from old backing file");
2235 goto out;
2236 }
2237 }
2238
2239 if (sector >= new_backing_num_sectors || !bs_new_backing) {
2240 memset(buf_new, 0, n * BDRV_SECTOR_SIZE);
2241 } else {
2242 if (sector + n > new_backing_num_sectors) {
2243 n = new_backing_num_sectors - sector;
2244 }
2245
2246 ret = bdrv_read(bs_new_backing, sector, buf_new, n);
2247 if (ret < 0) {
2248 error_report("error while reading from new backing file");
2249 goto out;
2250 }
2251 }
2252
2253 /* If they differ, we need to write to the COW file */
2254 uint64_t written = 0;
2255
2256 while (written < n) {
2257 int pnum;
2258
2259 if (compare_sectors(buf_old + written * 512,
2260 buf_new + written * 512, n - written, &pnum))
2261 {
2262 ret = bdrv_write(bs, sector + written,
2263 buf_old + written * 512, pnum);
2264 if (ret < 0) {
2265 error_report("Error while writing to COW image: %s",
2266 strerror(-ret));
2267 goto out;
2268 }
2269 }
2270
2271 written += pnum;
2272 }
2273 qemu_progress_print(local_progress, 100);
2274 }
2275
2276 qemu_vfree(buf_old);
2277 qemu_vfree(buf_new);
2278 }
2279
2280 /*
2281 * Change the backing file. All clusters that are different from the old
2282 * backing file are overwritten in the COW file now, so the visible content
2283 * doesn't change when we switch the backing file.
2284 */
2285 if (out_baseimg && *out_baseimg) {
2286 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
2287 } else {
2288 ret = bdrv_change_backing_file(bs, NULL, NULL);
2289 }
2290
2291 if (ret == -ENOSPC) {
2292 error_report("Could not change the backing file to '%s': No "
2293 "space left in the file header", out_baseimg);
2294 } else if (ret < 0) {
2295 error_report("Could not change the backing file to '%s': %s",
2296 out_baseimg, strerror(-ret));
2297 }
2298
2299 qemu_progress_print(100, 0);
2300 /*
2301 * TODO At this point it is possible to check if any clusters that are
2302 * allocated in the COW file are the same in the backing file. If so, they
2303 * could be dropped from the COW file. Don't do this before switching the
2304 * backing file, in case of a crash this would lead to corruption.
2305 */
2306 out:
2307 qemu_progress_end();
2308 /* Cleanup */
2309 if (!unsafe) {
2310 if (bs_old_backing != NULL) {
2311 bdrv_delete(bs_old_backing);
2312 }
2313 if (bs_new_backing != NULL) {
2314 bdrv_delete(bs_new_backing);
2315 }
2316 }
2317
2318 bdrv_delete(bs);
2319 if (ret) {
2320 return 1;
2321 }
2322 return 0;
2323 }
2324
2325 static int img_resize(int argc, char **argv)
2326 {
2327 int c, ret, relative;
2328 const char *filename, *fmt, *size;
2329 int64_t n, total_size;
2330 bool quiet = false;
2331 BlockDriverState *bs = NULL;
2332 QemuOpts *param;
2333 static QemuOptsList resize_options = {
2334 .name = "resize_options",
2335 .head = QTAILQ_HEAD_INITIALIZER(resize_options.head),
2336 .desc = {
2337 {
2338 .name = BLOCK_OPT_SIZE,
2339 .type = QEMU_OPT_SIZE,
2340 .help = "Virtual disk size"
2341 }, {
2342 /* end of list */
2343 }
2344 },
2345 };
2346
2347 /* Remove size from argv manually so that negative numbers are not treated
2348 * as options by getopt. */
2349 if (argc < 3) {
2350 help();
2351 return 1;
2352 }
2353
2354 size = argv[--argc];
2355
2356 /* Parse getopt arguments */
2357 fmt = NULL;
2358 for(;;) {
2359 c = getopt(argc, argv, "f:hq");
2360 if (c == -1) {
2361 break;
2362 }
2363 switch(c) {
2364 case '?':
2365 case 'h':
2366 help();
2367 break;
2368 case 'f':
2369 fmt = optarg;
2370 break;
2371 case 'q':
2372 quiet = true;
2373 break;
2374 }
2375 }
2376 if (optind >= argc) {
2377 help();
2378 }
2379 filename = argv[optind++];
2380
2381 /* Choose grow, shrink, or absolute resize mode */
2382 switch (size[0]) {
2383 case '+':
2384 relative = 1;
2385 size++;
2386 break;
2387 case '-':
2388 relative = -1;
2389 size++;
2390 break;
2391 default:
2392 relative = 0;
2393 break;
2394 }
2395
2396 /* Parse size */
2397 param = qemu_opts_create_nofail(&resize_options);
2398 if (qemu_opt_set(param, BLOCK_OPT_SIZE, size)) {
2399 /* Error message already printed when size parsing fails */
2400 ret = -1;
2401 qemu_opts_del(param);
2402 goto out;
2403 }
2404 n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
2405 qemu_opts_del(param);
2406
2407 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR, true, quiet);
2408 if (!bs) {
2409 ret = -1;
2410 goto out;
2411 }
2412
2413 if (relative) {
2414 total_size = bdrv_getlength(bs) + n * relative;
2415 } else {
2416 total_size = n;
2417 }
2418 if (total_size <= 0) {
2419 error_report("New image size must be positive");
2420 ret = -1;
2421 goto out;
2422 }
2423
2424 ret = bdrv_truncate(bs, total_size);
2425 switch (ret) {
2426 case 0:
2427 qprintf(quiet, "Image resized.\n");
2428 break;
2429 case -ENOTSUP:
2430 error_report("This image does not support resize");
2431 break;
2432 case -EACCES:
2433 error_report("Image is read-only");
2434 break;
2435 default:
2436 error_report("Error resizing image (%d)", -ret);
2437 break;
2438 }
2439 out:
2440 if (bs) {
2441 bdrv_delete(bs);
2442 }
2443 if (ret) {
2444 return 1;
2445 }
2446 return 0;
2447 }
2448
2449 static const img_cmd_t img_cmds[] = {
2450 #define DEF(option, callback, arg_string) \
2451 { option, callback },
2452 #include "qemu-img-cmds.h"
2453 #undef DEF
2454 #undef GEN_DOCS
2455 { NULL, NULL, },
2456 };
2457
2458 int main(int argc, char **argv)
2459 {
2460 const img_cmd_t *cmd;
2461 const char *cmdname;
2462
2463 error_set_progname(argv[0]);
2464
2465 qemu_init_main_loop();
2466 bdrv_init();
2467 if (argc < 2)
2468 help();
2469 cmdname = argv[1];
2470 argc--; argv++;
2471
2472 /* find the command */
2473 for(cmd = img_cmds; cmd->name != NULL; cmd++) {
2474 if (!strcmp(cmdname, cmd->name)) {
2475 return cmd->handler(argc, argv);
2476 }
2477 }
2478
2479 /* not found */
2480 help();
2481 return 0;
2482 }
QEmu