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