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