]> git.proxmox.com Git - mirror_qemu.git/blob - qemu-img.c
projects / mirror_qemu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
raw-posix: implement write_zeroes with MAY_UNMAP for files
[mirror_qemu.git] / qemu-img.c
1 /*
2 * QEMU disk image utility
3 *
4 * Copyright (c) 2003-2008 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24 #include "qapi-visit.h"
25 #include "qapi/qmp-output-visitor.h"
26 #include "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 if (bdrv_snapshot_load_tmp(bs[0], snapshot_name) < 0) {
1268 error_report("Failed to load snapshot");
1269 ret = -1;
1270 goto out;
1271 }
1272 }
1273
1274 /* Find driver and parse its options */
1275 drv = bdrv_find_format(out_fmt);
1276 if (!drv) {
1277 error_report("Unknown file format '%s'", out_fmt);
1278 ret = -1;
1279 goto out;
1280 }
1281
1282 proto_drv = bdrv_find_protocol(out_filename, true);
1283 if (!proto_drv) {
1284 error_report("Unknown protocol '%s'", out_filename);
1285 ret = -1;
1286 goto out;
1287 }
1288
1289 create_options = append_option_parameters(create_options,
1290 drv->create_options);
1291 create_options = append_option_parameters(create_options,
1292 proto_drv->create_options);
1293
1294 if (options) {
1295 param = parse_option_parameters(options, create_options, param);
1296 if (param == NULL) {
1297 error_report("Invalid options for file format '%s'.", out_fmt);
1298 ret = -1;
1299 goto out;
1300 }
1301 } else {
1302 param = parse_option_parameters("", create_options, param);
1303 }
1304
1305 set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
1306 ret = add_old_style_options(out_fmt, param, out_baseimg, NULL);
1307 if (ret < 0) {
1308 goto out;
1309 }
1310
1311 /* Get backing file name if -o backing_file was used */
1312 out_baseimg_param = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
1313 if (out_baseimg_param) {
1314 out_baseimg = out_baseimg_param->value.s;
1315 }
1316
1317 /* Check if compression is supported */
1318 if (compress) {
1319 QEMUOptionParameter *encryption =
1320 get_option_parameter(param, BLOCK_OPT_ENCRYPT);
1321 QEMUOptionParameter *preallocation =
1322 get_option_parameter(param, BLOCK_OPT_PREALLOC);
1323
1324 if (!drv->bdrv_write_compressed) {
1325 error_report("Compression not supported for this file format");
1326 ret = -1;
1327 goto out;
1328 }
1329
1330 if (encryption && encryption->value.n) {
1331 error_report("Compression and encryption not supported at "
1332 "the same time");
1333 ret = -1;
1334 goto out;
1335 }
1336
1337 if (preallocation && preallocation->value.s
1338 && strcmp(preallocation->value.s, "off"))
1339 {
1340 error_report("Compression and preallocation not supported at "
1341 "the same time");
1342 ret = -1;
1343 goto out;
1344 }
1345 }
1346
1347 if (!skip_create) {
1348 /* Create the new image */
1349 ret = bdrv_create(drv, out_filename, param, &local_err);
1350 if (ret < 0) {
1351 error_report("%s: error while converting %s: %s",
1352 out_filename, out_fmt, error_get_pretty(local_err));
1353 error_free(local_err);
1354 goto out;
1355 }
1356 }
1357
1358 flags = min_sparse ? (BDRV_O_RDWR | BDRV_O_UNMAP) : BDRV_O_RDWR;
1359 ret = bdrv_parse_cache_flags(cache, &flags);
1360 if (ret < 0) {
1361 error_report("Invalid cache option: %s", cache);
1362 return -1;
1363 }
1364
1365 out_bs = bdrv_new_open(out_filename, out_fmt, flags, true, quiet);
1366 if (!out_bs) {
1367 ret = -1;
1368 goto out;
1369 }
1370
1371 bs_i = 0;
1372 bs_offset = 0;
1373 bdrv_get_geometry(bs[0], &bs_sectors);
1374 buf = qemu_blockalign(out_bs, IO_BUF_SIZE);
1375
1376 if (skip_create) {
1377 int64_t output_length = bdrv_getlength(out_bs);
1378 if (output_length < 0) {
1379 error_report("unable to get output image length: %s\n",
1380 strerror(-output_length));
1381 ret = -1;
1382 goto out;
1383 } else if (output_length < total_sectors << BDRV_SECTOR_BITS) {
1384 error_report("output file is smaller than input file");
1385 ret = -1;
1386 goto out;
1387 }
1388 }
1389
1390 if (compress) {
1391 ret = bdrv_get_info(out_bs, &bdi);
1392 if (ret < 0) {
1393 error_report("could not get block driver info");
1394 goto out;
1395 }
1396 cluster_size = bdi.cluster_size;
1397 if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) {
1398 error_report("invalid cluster size");
1399 ret = -1;
1400 goto out;
1401 }
1402 cluster_sectors = cluster_size >> 9;
1403 sector_num = 0;
1404
1405 nb_sectors = total_sectors;
1406 if (nb_sectors != 0) {
1407 local_progress = (float)100 /
1408 (nb_sectors / MIN(nb_sectors, cluster_sectors));
1409 }
1410
1411 for(;;) {
1412 int64_t bs_num;
1413 int remainder;
1414 uint8_t *buf2;
1415
1416 nb_sectors = total_sectors - sector_num;
1417 if (nb_sectors <= 0)
1418 break;
1419 if (nb_sectors >= cluster_sectors)
1420 n = cluster_sectors;
1421 else
1422 n = nb_sectors;
1423
1424 bs_num = sector_num - bs_offset;
1425 assert (bs_num >= 0);
1426 remainder = n;
1427 buf2 = buf;
1428 while (remainder > 0) {
1429 int nlow;
1430 while (bs_num == bs_sectors) {
1431 bs_i++;
1432 assert (bs_i < bs_n);
1433 bs_offset += bs_sectors;
1434 bdrv_get_geometry(bs[bs_i], &bs_sectors);
1435 bs_num = 0;
1436 /* printf("changing part: sector_num=%" PRId64 ", "
1437 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
1438 "\n", sector_num, bs_i, bs_offset, bs_sectors); */
1439 }
1440 assert (bs_num < bs_sectors);
1441
1442 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;
1443
1444 ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow);
1445 if (ret < 0) {
1446 error_report("error while reading sector %" PRId64 ": %s",
1447 bs_num, strerror(-ret));
1448 goto out;
1449 }
1450
1451 buf2 += nlow * 512;
1452 bs_num += nlow;
1453
1454 remainder -= nlow;
1455 }
1456 assert (remainder == 0);
1457
1458 if (!buffer_is_zero(buf, n * BDRV_SECTOR_SIZE)) {
1459 ret = bdrv_write_compressed(out_bs, sector_num, buf, n);
1460 if (ret != 0) {
1461 error_report("error while compressing sector %" PRId64
1462 ": %s", sector_num, strerror(-ret));
1463 goto out;
1464 }
1465 }
1466 sector_num += n;
1467 qemu_progress_print(local_progress, 100);
1468 }
1469 /* signal EOF to align */
1470 bdrv_write_compressed(out_bs, 0, NULL, 0);
1471 } else {
1472 int has_zero_init = min_sparse ? bdrv_has_zero_init(out_bs) : 0;
1473
1474 if (!has_zero_init && bdrv_can_write_zeroes_with_unmap(out_bs)) {
1475 ret = bdrv_make_zero(out_bs, BDRV_REQ_MAY_UNMAP);
1476 if (ret < 0) {
1477 goto out;
1478 }
1479 has_zero_init = 1;
1480 }
1481
1482 sector_num = 0; // total number of sectors converted so far
1483 nb_sectors = total_sectors - sector_num;
1484 if (nb_sectors != 0) {
1485 local_progress = (float)100 /
1486 (nb_sectors / MIN(nb_sectors, IO_BUF_SIZE / 512));
1487 }
1488
1489 for(;;) {
1490 nb_sectors = total_sectors - sector_num;
1491 if (nb_sectors <= 0) {
1492 break;
1493 }
1494 if (nb_sectors >= (IO_BUF_SIZE / 512)) {
1495 n = (IO_BUF_SIZE / 512);
1496 } else {
1497 n = nb_sectors;
1498 }
1499
1500 while (sector_num - bs_offset >= bs_sectors) {
1501 bs_i ++;
1502 assert (bs_i < bs_n);
1503 bs_offset += bs_sectors;
1504 bdrv_get_geometry(bs[bs_i], &bs_sectors);
1505 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
1506 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
1507 sector_num, bs_i, bs_offset, bs_sectors); */
1508 }
1509
1510 if (n > bs_offset + bs_sectors - sector_num) {
1511 n = bs_offset + bs_sectors - sector_num;
1512 }
1513
1514 /* If the output image is being created as a copy on write image,
1515 assume that sectors which are unallocated in the input image
1516 are present in both the output's and input's base images (no
1517 need to copy them). */
1518 if (out_baseimg) {
1519 ret = bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
1520 n, &n1);
1521 if (ret < 0) {
1522 error_report("error while reading metadata for sector "
1523 "%" PRId64 ": %s",
1524 sector_num - bs_offset, strerror(-ret));
1525 goto out;
1526 }
1527 if (!ret) {
1528 sector_num += n1;
1529 continue;
1530 }
1531 /* The next 'n1' sectors are allocated in the input image. Copy
1532 only those as they may be followed by unallocated sectors. */
1533 n = n1;
1534 } else {
1535 n1 = n;
1536 }
1537
1538 ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
1539 if (ret < 0) {
1540 error_report("error while reading sector %" PRId64 ": %s",
1541 sector_num - bs_offset, strerror(-ret));
1542 goto out;
1543 }
1544 /* NOTE: at the same time we convert, we do not write zero
1545 sectors to have a chance to compress the image. Ideally, we
1546 should add a specific call to have the info to go faster */
1547 buf1 = buf;
1548 while (n > 0) {
1549 if (!has_zero_init ||
1550 is_allocated_sectors_min(buf1, n, &n1, min_sparse)) {
1551 ret = bdrv_write(out_bs, sector_num, buf1, n1);
1552 if (ret < 0) {
1553 error_report("error while writing sector %" PRId64
1554 ": %s", sector_num, strerror(-ret));
1555 goto out;
1556 }
1557 }
1558 sector_num += n1;
1559 n -= n1;
1560 buf1 += n1 * 512;
1561 }
1562 qemu_progress_print(local_progress, 100);
1563 }
1564 }
1565 out:
1566 qemu_progress_end();
1567 free_option_parameters(create_options);
1568 free_option_parameters(param);
1569 qemu_vfree(buf);
1570 if (out_bs) {
1571 bdrv_unref(out_bs);
1572 }
1573 if (bs) {
1574 for (bs_i = 0; bs_i < bs_n; bs_i++) {
1575 if (bs[bs_i]) {
1576 bdrv_unref(bs[bs_i]);
1577 }
1578 }
1579 g_free(bs);
1580 }
1581 if (ret) {
1582 return 1;
1583 }
1584 return 0;
1585 }
1586
1587
1588 static void dump_snapshots(BlockDriverState *bs)
1589 {
1590 QEMUSnapshotInfo *sn_tab, *sn;
1591 int nb_sns, i;
1592
1593 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1594 if (nb_sns <= 0)
1595 return;
1596 printf("Snapshot list:\n");
1597 bdrv_snapshot_dump(fprintf, stdout, NULL);
1598 printf("\n");
1599 for(i = 0; i < nb_sns; i++) {
1600 sn = &sn_tab[i];
1601 bdrv_snapshot_dump(fprintf, stdout, sn);
1602 printf("\n");
1603 }
1604 g_free(sn_tab);
1605 }
1606
1607 static void dump_json_image_info_list(ImageInfoList *list)
1608 {
1609 Error *errp = NULL;
1610 QString *str;
1611 QmpOutputVisitor *ov = qmp_output_visitor_new();
1612 QObject *obj;
1613 visit_type_ImageInfoList(qmp_output_get_visitor(ov),
1614 &list, NULL, &errp);
1615 obj = qmp_output_get_qobject(ov);
1616 str = qobject_to_json_pretty(obj);
1617 assert(str != NULL);
1618 printf("%s\n", qstring_get_str(str));
1619 qobject_decref(obj);
1620 qmp_output_visitor_cleanup(ov);
1621 QDECREF(str);
1622 }
1623
1624 static void dump_json_image_info(ImageInfo *info)
1625 {
1626 Error *errp = NULL;
1627 QString *str;
1628 QmpOutputVisitor *ov = qmp_output_visitor_new();
1629 QObject *obj;
1630 visit_type_ImageInfo(qmp_output_get_visitor(ov),
1631 &info, NULL, &errp);
1632 obj = qmp_output_get_qobject(ov);
1633 str = qobject_to_json_pretty(obj);
1634 assert(str != NULL);
1635 printf("%s\n", qstring_get_str(str));
1636 qobject_decref(obj);
1637 qmp_output_visitor_cleanup(ov);
1638 QDECREF(str);
1639 }
1640
1641 static void dump_human_image_info_list(ImageInfoList *list)
1642 {
1643 ImageInfoList *elem;
1644 bool delim = false;
1645
1646 for (elem = list; elem; elem = elem->next) {
1647 if (delim) {
1648 printf("\n");
1649 }
1650 delim = true;
1651
1652 bdrv_image_info_dump(fprintf, stdout, elem->value);
1653 }
1654 }
1655
1656 static gboolean str_equal_func(gconstpointer a, gconstpointer b)
1657 {
1658 return strcmp(a, b) == 0;
1659 }
1660
1661 /**
1662 * Open an image file chain and return an ImageInfoList
1663 *
1664 * @filename: topmost image filename
1665 * @fmt: topmost image format (may be NULL to autodetect)
1666 * @chain: true - enumerate entire backing file chain
1667 * false - only topmost image file
1668 *
1669 * Returns a list of ImageInfo objects or NULL if there was an error opening an
1670 * image file. If there was an error a message will have been printed to
1671 * stderr.
1672 */
1673 static ImageInfoList *collect_image_info_list(const char *filename,
1674 const char *fmt,
1675 bool chain)
1676 {
1677 ImageInfoList *head = NULL;
1678 ImageInfoList **last = &head;
1679 GHashTable *filenames;
1680 Error *err = NULL;
1681
1682 filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL);
1683
1684 while (filename) {
1685 BlockDriverState *bs;
1686 ImageInfo *info;
1687 ImageInfoList *elem;
1688
1689 if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) {
1690 error_report("Backing file '%s' creates an infinite loop.",
1691 filename);
1692 goto err;
1693 }
1694 g_hash_table_insert(filenames, (gpointer)filename, NULL);
1695
1696 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING,
1697 false, false);
1698 if (!bs) {
1699 goto err;
1700 }
1701
1702 bdrv_query_image_info(bs, &info, &err);
1703 if (error_is_set(&err)) {
1704 error_report("%s", error_get_pretty(err));
1705 error_free(err);
1706 goto err;
1707 }
1708
1709 elem = g_new0(ImageInfoList, 1);
1710 elem->value = info;
1711 *last = elem;
1712 last = &elem->next;
1713
1714 bdrv_unref(bs);
1715
1716 filename = fmt = NULL;
1717 if (chain) {
1718 if (info->has_full_backing_filename) {
1719 filename = info->full_backing_filename;
1720 } else if (info->has_backing_filename) {
1721 filename = info->backing_filename;
1722 }
1723 if (info->has_backing_filename_format) {
1724 fmt = info->backing_filename_format;
1725 }
1726 }
1727 }
1728 g_hash_table_destroy(filenames);
1729 return head;
1730
1731 err:
1732 qapi_free_ImageInfoList(head);
1733 g_hash_table_destroy(filenames);
1734 return NULL;
1735 }
1736
1737 static int img_info(int argc, char **argv)
1738 {
1739 int c;
1740 OutputFormat output_format = OFORMAT_HUMAN;
1741 bool chain = false;
1742 const char *filename, *fmt, *output;
1743 ImageInfoList *list;
1744
1745 fmt = NULL;
1746 output = NULL;
1747 for(;;) {
1748 int option_index = 0;
1749 static const struct option long_options[] = {
1750 {"help", no_argument, 0, 'h'},
1751 {"format", required_argument, 0, 'f'},
1752 {"output", required_argument, 0, OPTION_OUTPUT},
1753 {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN},
1754 {0, 0, 0, 0}
1755 };
1756 c = getopt_long(argc, argv, "f:h",
1757 long_options, &option_index);
1758 if (c == -1) {
1759 break;
1760 }
1761 switch(c) {
1762 case '?':
1763 case 'h':
1764 help();
1765 break;
1766 case 'f':
1767 fmt = optarg;
1768 break;
1769 case OPTION_OUTPUT:
1770 output = optarg;
1771 break;
1772 case OPTION_BACKING_CHAIN:
1773 chain = true;
1774 break;
1775 }
1776 }
1777 if (optind != argc - 1) {
1778 help();
1779 }
1780 filename = argv[optind++];
1781
1782 if (output && !strcmp(output, "json")) {
1783 output_format = OFORMAT_JSON;
1784 } else if (output && !strcmp(output, "human")) {
1785 output_format = OFORMAT_HUMAN;
1786 } else if (output) {
1787 error_report("--output must be used with human or json as argument.");
1788 return 1;
1789 }
1790
1791 list = collect_image_info_list(filename, fmt, chain);
1792 if (!list) {
1793 return 1;
1794 }
1795
1796 switch (output_format) {
1797 case OFORMAT_HUMAN:
1798 dump_human_image_info_list(list);
1799 break;
1800 case OFORMAT_JSON:
1801 if (chain) {
1802 dump_json_image_info_list(list);
1803 } else {
1804 dump_json_image_info(list->value);
1805 }
1806 break;
1807 }
1808
1809 qapi_free_ImageInfoList(list);
1810 return 0;
1811 }
1812
1813
1814 typedef struct MapEntry {
1815 int flags;
1816 int depth;
1817 int64_t start;
1818 int64_t length;
1819 int64_t offset;
1820 BlockDriverState *bs;
1821 } MapEntry;
1822
1823 static void dump_map_entry(OutputFormat output_format, MapEntry *e,
1824 MapEntry *next)
1825 {
1826 switch (output_format) {
1827 case OFORMAT_HUMAN:
1828 if ((e->flags & BDRV_BLOCK_DATA) &&
1829 !(e->flags & BDRV_BLOCK_OFFSET_VALID)) {
1830 error_report("File contains external, encrypted or compressed clusters.");
1831 exit(1);
1832 }
1833 if ((e->flags & (BDRV_BLOCK_DATA|BDRV_BLOCK_ZERO)) == BDRV_BLOCK_DATA) {
1834 printf("%#-16"PRIx64"%#-16"PRIx64"%#-16"PRIx64"%s\n",
1835 e->start, e->length, e->offset, e->bs->filename);
1836 }
1837 /* This format ignores the distinction between 0, ZERO and ZERO|DATA.
1838 * Modify the flags here to allow more coalescing.
1839 */
1840 if (next &&
1841 (next->flags & (BDRV_BLOCK_DATA|BDRV_BLOCK_ZERO)) != BDRV_BLOCK_DATA) {
1842 next->flags &= ~BDRV_BLOCK_DATA;
1843 next->flags |= BDRV_BLOCK_ZERO;
1844 }
1845 break;
1846 case OFORMAT_JSON:
1847 printf("%s{ \"start\": %"PRId64", \"length\": %"PRId64", \"depth\": %d,"
1848 " \"zero\": %s, \"data\": %s",
1849 (e->start == 0 ? "[" : ",\n"),
1850 e->start, e->length, e->depth,
1851 (e->flags & BDRV_BLOCK_ZERO) ? "true" : "false",
1852 (e->flags & BDRV_BLOCK_DATA) ? "true" : "false");
1853 if (e->flags & BDRV_BLOCK_OFFSET_VALID) {
1854 printf(", \"offset\": %"PRId64"", e->offset);
1855 }
1856 putchar('}');
1857
1858 if (!next) {
1859 printf("]\n");
1860 }
1861 break;
1862 }
1863 }
1864
1865 static int get_block_status(BlockDriverState *bs, int64_t sector_num,
1866 int nb_sectors, MapEntry *e)
1867 {
1868 int64_t ret;
1869 int depth;
1870
1871 /* As an optimization, we could cache the current range of unallocated
1872 * clusters in each file of the chain, and avoid querying the same
1873 * range repeatedly.
1874 */
1875
1876 depth = 0;
1877 for (;;) {
1878 ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &nb_sectors);
1879 if (ret < 0) {
1880 return ret;
1881 }
1882 assert(nb_sectors);
1883 if (ret & (BDRV_BLOCK_ZERO|BDRV_BLOCK_DATA)) {
1884 break;
1885 }
1886 bs = bs->backing_hd;
1887 if (bs == NULL) {
1888 ret = 0;
1889 break;
1890 }
1891
1892 depth++;
1893 }
1894
1895 e->start = sector_num * BDRV_SECTOR_SIZE;
1896 e->length = nb_sectors * BDRV_SECTOR_SIZE;
1897 e->flags = ret & ~BDRV_BLOCK_OFFSET_MASK;
1898 e->offset = ret & BDRV_BLOCK_OFFSET_MASK;
1899 e->depth = depth;
1900 e->bs = bs;
1901 return 0;
1902 }
1903
1904 static int img_map(int argc, char **argv)
1905 {
1906 int c;
1907 OutputFormat output_format = OFORMAT_HUMAN;
1908 BlockDriverState *bs;
1909 const char *filename, *fmt, *output;
1910 int64_t length;
1911 MapEntry curr = { .length = 0 }, next;
1912 int ret = 0;
1913
1914 fmt = NULL;
1915 output = NULL;
1916 for (;;) {
1917 int option_index = 0;
1918 static const struct option long_options[] = {
1919 {"help", no_argument, 0, 'h'},
1920 {"format", required_argument, 0, 'f'},
1921 {"output", required_argument, 0, OPTION_OUTPUT},
1922 {0, 0, 0, 0}
1923 };
1924 c = getopt_long(argc, argv, "f:h",
1925 long_options, &option_index);
1926 if (c == -1) {
1927 break;
1928 }
1929 switch (c) {
1930 case '?':
1931 case 'h':
1932 help();
1933 break;
1934 case 'f':
1935 fmt = optarg;
1936 break;
1937 case OPTION_OUTPUT:
1938 output = optarg;
1939 break;
1940 }
1941 }
1942 if (optind >= argc) {
1943 help();
1944 }
1945 filename = argv[optind++];
1946
1947 if (output && !strcmp(output, "json")) {
1948 output_format = OFORMAT_JSON;
1949 } else if (output && !strcmp(output, "human")) {
1950 output_format = OFORMAT_HUMAN;
1951 } else if (output) {
1952 error_report("--output must be used with human or json as argument.");
1953 return 1;
1954 }
1955
1956 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS, true, false);
1957 if (!bs) {
1958 return 1;
1959 }
1960
1961 if (output_format == OFORMAT_HUMAN) {
1962 printf("%-16s%-16s%-16s%s\n", "Offset", "Length", "Mapped to", "File");
1963 }
1964
1965 length = bdrv_getlength(bs);
1966 while (curr.start + curr.length < length) {
1967 int64_t nsectors_left;
1968 int64_t sector_num;
1969 int n;
1970
1971 sector_num = (curr.start + curr.length) >> BDRV_SECTOR_BITS;
1972
1973 /* Probe up to 1 GiB at a time. */
1974 nsectors_left = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE) - sector_num;
1975 n = MIN(1 << (30 - BDRV_SECTOR_BITS), nsectors_left);
1976 ret = get_block_status(bs, sector_num, n, &next);
1977
1978 if (ret < 0) {
1979 error_report("Could not read file metadata: %s", strerror(-ret));
1980 goto out;
1981 }
1982
1983 if (curr.length != 0 && curr.flags == next.flags &&
1984 curr.depth == next.depth &&
1985 ((curr.flags & BDRV_BLOCK_OFFSET_VALID) == 0 ||
1986 curr.offset + curr.length == next.offset)) {
1987 curr.length += next.length;
1988 continue;
1989 }
1990
1991 if (curr.length > 0) {
1992 dump_map_entry(output_format, &curr, &next);
1993 }
1994 curr = next;
1995 }
1996
1997 dump_map_entry(output_format, &curr, NULL);
1998
1999 out:
2000 bdrv_unref(bs);
2001 return ret < 0;
2002 }
2003
2004 #define SNAPSHOT_LIST 1
2005 #define SNAPSHOT_CREATE 2
2006 #define SNAPSHOT_APPLY 3
2007 #define SNAPSHOT_DELETE 4
2008
2009 static int img_snapshot(int argc, char **argv)
2010 {
2011 BlockDriverState *bs;
2012 QEMUSnapshotInfo sn;
2013 char *filename, *snapshot_name = NULL;
2014 int c, ret = 0, bdrv_oflags;
2015 int action = 0;
2016 qemu_timeval tv;
2017 bool quiet = false;
2018 Error *err = NULL;
2019
2020 bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
2021 /* Parse commandline parameters */
2022 for(;;) {
2023 c = getopt(argc, argv, "la:c:d:hq");
2024 if (c == -1) {
2025 break;
2026 }
2027 switch(c) {
2028 case '?':
2029 case 'h':
2030 help();
2031 return 0;
2032 case 'l':
2033 if (action) {
2034 help();
2035 return 0;
2036 }
2037 action = SNAPSHOT_LIST;
2038 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
2039 break;
2040 case 'a':
2041 if (action) {
2042 help();
2043 return 0;
2044 }
2045 action = SNAPSHOT_APPLY;
2046 snapshot_name = optarg;
2047 break;
2048 case 'c':
2049 if (action) {
2050 help();
2051 return 0;
2052 }
2053 action = SNAPSHOT_CREATE;
2054 snapshot_name = optarg;
2055 break;
2056 case 'd':
2057 if (action) {
2058 help();
2059 return 0;
2060 }
2061 action = SNAPSHOT_DELETE;
2062 snapshot_name = optarg;
2063 break;
2064 case 'q':
2065 quiet = true;
2066 break;
2067 }
2068 }
2069
2070 if (optind != argc - 1) {
2071 help();
2072 }
2073 filename = argv[optind++];
2074
2075 /* Open the image */
2076 bs = bdrv_new_open(filename, NULL, bdrv_oflags, true, quiet);
2077 if (!bs) {
2078 return 1;
2079 }
2080
2081 /* Perform the requested action */
2082 switch(action) {
2083 case SNAPSHOT_LIST:
2084 dump_snapshots(bs);
2085 break;
2086
2087 case SNAPSHOT_CREATE:
2088 memset(&sn, 0, sizeof(sn));
2089 pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
2090
2091 qemu_gettimeofday(&tv);
2092 sn.date_sec = tv.tv_sec;
2093 sn.date_nsec = tv.tv_usec * 1000;
2094
2095 ret = bdrv_snapshot_create(bs, &sn);
2096 if (ret) {
2097 error_report("Could not create snapshot '%s': %d (%s)",
2098 snapshot_name, ret, strerror(-ret));
2099 }
2100 break;
2101
2102 case SNAPSHOT_APPLY:
2103 ret = bdrv_snapshot_goto(bs, snapshot_name);
2104 if (ret) {
2105 error_report("Could not apply snapshot '%s': %d (%s)",
2106 snapshot_name, ret, strerror(-ret));
2107 }
2108 break;
2109
2110 case SNAPSHOT_DELETE:
2111 bdrv_snapshot_delete_by_id_or_name(bs, snapshot_name, &err);
2112 if (error_is_set(&err)) {
2113 error_report("Could not delete snapshot '%s': (%s)",
2114 snapshot_name, error_get_pretty(err));
2115 error_free(err);
2116 ret = 1;
2117 }
2118 break;
2119 }
2120
2121 /* Cleanup */
2122 bdrv_unref(bs);
2123 if (ret) {
2124 return 1;
2125 }
2126 return 0;
2127 }
2128
2129 static int img_rebase(int argc, char **argv)
2130 {
2131 BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
2132 BlockDriver *old_backing_drv, *new_backing_drv;
2133 char *filename;
2134 const char *fmt, *cache, *out_basefmt, *out_baseimg;
2135 int c, flags, ret;
2136 int unsafe = 0;
2137 int progress = 0;
2138 bool quiet = false;
2139 Error *local_err = NULL;
2140
2141 /* Parse commandline parameters */
2142 fmt = NULL;
2143 cache = BDRV_DEFAULT_CACHE;
2144 out_baseimg = NULL;
2145 out_basefmt = NULL;
2146 for(;;) {
2147 c = getopt(argc, argv, "uhf:F:b:pt:q");
2148 if (c == -1) {
2149 break;
2150 }
2151 switch(c) {
2152 case '?':
2153 case 'h':
2154 help();
2155 return 0;
2156 case 'f':
2157 fmt = optarg;
2158 break;
2159 case 'F':
2160 out_basefmt = optarg;
2161 break;
2162 case 'b':
2163 out_baseimg = optarg;
2164 break;
2165 case 'u':
2166 unsafe = 1;
2167 break;
2168 case 'p':
2169 progress = 1;
2170 break;
2171 case 't':
2172 cache = optarg;
2173 break;
2174 case 'q':
2175 quiet = true;
2176 break;
2177 }
2178 }
2179
2180 if (quiet) {
2181 progress = 0;
2182 }
2183
2184 if ((optind != argc - 1) || (!unsafe && !out_baseimg)) {
2185 help();
2186 }
2187 filename = argv[optind++];
2188
2189 qemu_progress_init(progress, 2.0);
2190 qemu_progress_print(0, 100);
2191
2192 flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
2193 ret = bdrv_parse_cache_flags(cache, &flags);
2194 if (ret < 0) {
2195 error_report("Invalid cache option: %s", cache);
2196 return -1;
2197 }
2198
2199 /*
2200 * Open the images.
2201 *
2202 * Ignore the old backing file for unsafe rebase in case we want to correct
2203 * the reference to a renamed or moved backing file.
2204 */
2205 bs = bdrv_new_open(filename, fmt, flags, true, quiet);
2206 if (!bs) {
2207 return 1;
2208 }
2209
2210 /* Find the right drivers for the backing files */
2211 old_backing_drv = NULL;
2212 new_backing_drv = NULL;
2213
2214 if (!unsafe && bs->backing_format[0] != '\0') {
2215 old_backing_drv = bdrv_find_format(bs->backing_format);
2216 if (old_backing_drv == NULL) {
2217 error_report("Invalid format name: '%s'", bs->backing_format);
2218 ret = -1;
2219 goto out;
2220 }
2221 }
2222
2223 if (out_basefmt != NULL) {
2224 new_backing_drv = bdrv_find_format(out_basefmt);
2225 if (new_backing_drv == NULL) {
2226 error_report("Invalid format name: '%s'", out_basefmt);
2227 ret = -1;
2228 goto out;
2229 }
2230 }
2231
2232 /* For safe rebasing we need to compare old and new backing file */
2233 if (unsafe) {
2234 /* Make the compiler happy */
2235 bs_old_backing = NULL;
2236 bs_new_backing = NULL;
2237 } else {
2238 char backing_name[1024];
2239
2240 bs_old_backing = bdrv_new("old_backing");
2241 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
2242 ret = bdrv_open(bs_old_backing, backing_name, NULL, BDRV_O_FLAGS,
2243 old_backing_drv, &local_err);
2244 if (ret) {
2245 error_report("Could not open old backing file '%s': %s",
2246 backing_name, error_get_pretty(local_err));
2247 error_free(local_err);
2248 goto out;
2249 }
2250 if (out_baseimg[0]) {
2251 bs_new_backing = bdrv_new("new_backing");
2252 ret = bdrv_open(bs_new_backing, out_baseimg, NULL, BDRV_O_FLAGS,
2253 new_backing_drv, &local_err);
2254 if (ret) {
2255 error_report("Could not open new backing file '%s': %s",
2256 out_baseimg, error_get_pretty(local_err));
2257 error_free(local_err);
2258 goto out;
2259 }
2260 }
2261 }
2262
2263 /*
2264 * Check each unallocated cluster in the COW file. If it is unallocated,
2265 * accesses go to the backing file. We must therefore compare this cluster
2266 * in the old and new backing file, and if they differ we need to copy it
2267 * from the old backing file into the COW file.
2268 *
2269 * If qemu-img crashes during this step, no harm is done. The content of
2270 * the image is the same as the original one at any time.
2271 */
2272 if (!unsafe) {
2273 uint64_t num_sectors;
2274 uint64_t old_backing_num_sectors;
2275 uint64_t new_backing_num_sectors = 0;
2276 uint64_t sector;
2277 int n;
2278 uint8_t * buf_old;
2279 uint8_t * buf_new;
2280 float local_progress = 0;
2281
2282 buf_old = qemu_blockalign(bs, IO_BUF_SIZE);
2283 buf_new = qemu_blockalign(bs, IO_BUF_SIZE);
2284
2285 bdrv_get_geometry(bs, &num_sectors);
2286 bdrv_get_geometry(bs_old_backing, &old_backing_num_sectors);
2287 if (bs_new_backing) {
2288 bdrv_get_geometry(bs_new_backing, &new_backing_num_sectors);
2289 }
2290
2291 if (num_sectors != 0) {
2292 local_progress = (float)100 /
2293 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
2294 }
2295
2296 for (sector = 0; sector < num_sectors; sector += n) {
2297
2298 /* How many sectors can we handle with the next read? */
2299 if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
2300 n = (IO_BUF_SIZE / 512);
2301 } else {
2302 n = num_sectors - sector;
2303 }
2304
2305 /* If the cluster is allocated, we don't need to take action */
2306 ret = bdrv_is_allocated(bs, sector, n, &n);
2307 if (ret < 0) {
2308 error_report("error while reading image metadata: %s",
2309 strerror(-ret));
2310 goto out;
2311 }
2312 if (ret) {
2313 continue;
2314 }
2315
2316 /*
2317 * Read old and new backing file and take into consideration that
2318 * backing files may be smaller than the COW image.
2319 */
2320 if (sector >= old_backing_num_sectors) {
2321 memset(buf_old, 0, n * BDRV_SECTOR_SIZE);
2322 } else {
2323 if (sector + n > old_backing_num_sectors) {
2324 n = old_backing_num_sectors - sector;
2325 }
2326
2327 ret = bdrv_read(bs_old_backing, sector, buf_old, n);
2328 if (ret < 0) {
2329 error_report("error while reading from old backing file");
2330 goto out;
2331 }
2332 }
2333
2334 if (sector >= new_backing_num_sectors || !bs_new_backing) {
2335 memset(buf_new, 0, n * BDRV_SECTOR_SIZE);
2336 } else {
2337 if (sector + n > new_backing_num_sectors) {
2338 n = new_backing_num_sectors - sector;
2339 }
2340
2341 ret = bdrv_read(bs_new_backing, sector, buf_new, n);
2342 if (ret < 0) {
2343 error_report("error while reading from new backing file");
2344 goto out;
2345 }
2346 }
2347
2348 /* If they differ, we need to write to the COW file */
2349 uint64_t written = 0;
2350
2351 while (written < n) {
2352 int pnum;
2353
2354 if (compare_sectors(buf_old + written * 512,
2355 buf_new + written * 512, n - written, &pnum))
2356 {
2357 ret = bdrv_write(bs, sector + written,
2358 buf_old + written * 512, pnum);
2359 if (ret < 0) {
2360 error_report("Error while writing to COW image: %s",
2361 strerror(-ret));
2362 goto out;
2363 }
2364 }
2365
2366 written += pnum;
2367 }
2368 qemu_progress_print(local_progress, 100);
2369 }
2370
2371 qemu_vfree(buf_old);
2372 qemu_vfree(buf_new);
2373 }
2374
2375 /*
2376 * Change the backing file. All clusters that are different from the old
2377 * backing file are overwritten in the COW file now, so the visible content
2378 * doesn't change when we switch the backing file.
2379 */
2380 if (out_baseimg && *out_baseimg) {
2381 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
2382 } else {
2383 ret = bdrv_change_backing_file(bs, NULL, NULL);
2384 }
2385
2386 if (ret == -ENOSPC) {
2387 error_report("Could not change the backing file to '%s': No "
2388 "space left in the file header", out_baseimg);
2389 } else if (ret < 0) {
2390 error_report("Could not change the backing file to '%s': %s",
2391 out_baseimg, strerror(-ret));
2392 }
2393
2394 qemu_progress_print(100, 0);
2395 /*
2396 * TODO At this point it is possible to check if any clusters that are
2397 * allocated in the COW file are the same in the backing file. If so, they
2398 * could be dropped from the COW file. Don't do this before switching the
2399 * backing file, in case of a crash this would lead to corruption.
2400 */
2401 out:
2402 qemu_progress_end();
2403 /* Cleanup */
2404 if (!unsafe) {
2405 if (bs_old_backing != NULL) {
2406 bdrv_unref(bs_old_backing);
2407 }
2408 if (bs_new_backing != NULL) {
2409 bdrv_unref(bs_new_backing);
2410 }
2411 }
2412
2413 bdrv_unref(bs);
2414 if (ret) {
2415 return 1;
2416 }
2417 return 0;
2418 }
2419
2420 static int img_resize(int argc, char **argv)
2421 {
2422 int c, ret, relative;
2423 const char *filename, *fmt, *size;
2424 int64_t n, total_size;
2425 bool quiet = false;
2426 BlockDriverState *bs = NULL;
2427 QemuOpts *param;
2428 static QemuOptsList resize_options = {
2429 .name = "resize_options",
2430 .head = QTAILQ_HEAD_INITIALIZER(resize_options.head),
2431 .desc = {
2432 {
2433 .name = BLOCK_OPT_SIZE,
2434 .type = QEMU_OPT_SIZE,
2435 .help = "Virtual disk size"
2436 }, {
2437 /* end of list */
2438 }
2439 },
2440 };
2441
2442 /* Remove size from argv manually so that negative numbers are not treated
2443 * as options by getopt. */
2444 if (argc < 3) {
2445 help();
2446 return 1;
2447 }
2448
2449 size = argv[--argc];
2450
2451 /* Parse getopt arguments */
2452 fmt = NULL;
2453 for(;;) {
2454 c = getopt(argc, argv, "f:hq");
2455 if (c == -1) {
2456 break;
2457 }
2458 switch(c) {
2459 case '?':
2460 case 'h':
2461 help();
2462 break;
2463 case 'f':
2464 fmt = optarg;
2465 break;
2466 case 'q':
2467 quiet = true;
2468 break;
2469 }
2470 }
2471 if (optind != argc - 1) {
2472 help();
2473 }
2474 filename = argv[optind++];
2475
2476 /* Choose grow, shrink, or absolute resize mode */
2477 switch (size[0]) {
2478 case '+':
2479 relative = 1;
2480 size++;
2481 break;
2482 case '-':
2483 relative = -1;
2484 size++;
2485 break;
2486 default:
2487 relative = 0;
2488 break;
2489 }
2490
2491 /* Parse size */
2492 param = qemu_opts_create_nofail(&resize_options);
2493 if (qemu_opt_set(param, BLOCK_OPT_SIZE, size)) {
2494 /* Error message already printed when size parsing fails */
2495 ret = -1;
2496 qemu_opts_del(param);
2497 goto out;
2498 }
2499 n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
2500 qemu_opts_del(param);
2501
2502 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR, true, quiet);
2503 if (!bs) {
2504 ret = -1;
2505 goto out;
2506 }
2507
2508 if (relative) {
2509 total_size = bdrv_getlength(bs) + n * relative;
2510 } else {
2511 total_size = n;
2512 }
2513 if (total_size <= 0) {
2514 error_report("New image size must be positive");
2515 ret = -1;
2516 goto out;
2517 }
2518
2519 ret = bdrv_truncate(bs, total_size);
2520 switch (ret) {
2521 case 0:
2522 qprintf(quiet, "Image resized.\n");
2523 break;
2524 case -ENOTSUP:
2525 error_report("This image does not support resize");
2526 break;
2527 case -EACCES:
2528 error_report("Image is read-only");
2529 break;
2530 default:
2531 error_report("Error resizing image (%d)", -ret);
2532 break;
2533 }
2534 out:
2535 if (bs) {
2536 bdrv_unref(bs);
2537 }
2538 if (ret) {
2539 return 1;
2540 }
2541 return 0;
2542 }
2543
2544 static int img_amend(int argc, char **argv)
2545 {
2546 int c, ret = 0;
2547 char *options = NULL;
2548 QEMUOptionParameter *create_options = NULL, *options_param = NULL;
2549 const char *fmt = NULL, *filename;
2550 bool quiet = false;
2551 BlockDriverState *bs = NULL;
2552
2553 for (;;) {
2554 c = getopt(argc, argv, "hqf:o:");
2555 if (c == -1) {
2556 break;
2557 }
2558
2559 switch (c) {
2560 case 'h':
2561 case '?':
2562 help();
2563 break;
2564 case 'o':
2565 options = optarg;
2566 break;
2567 case 'f':
2568 fmt = optarg;
2569 break;
2570 case 'q':
2571 quiet = true;
2572 break;
2573 }
2574 }
2575
2576 if (optind != argc - 1) {
2577 help();
2578 }
2579
2580 if (!options) {
2581 help();
2582 }
2583
2584 filename = argv[argc - 1];
2585
2586 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR, true, quiet);
2587 if (!bs) {
2588 error_report("Could not open image '%s'", filename);
2589 ret = -1;
2590 goto out;
2591 }
2592
2593 fmt = bs->drv->format_name;
2594
2595 if (is_help_option(options)) {
2596 ret = print_block_option_help(filename, fmt);
2597 goto out;
2598 }
2599
2600 create_options = append_option_parameters(create_options,
2601 bs->drv->create_options);
2602 options_param = parse_option_parameters(options, create_options,
2603 options_param);
2604 if (options_param == NULL) {
2605 error_report("Invalid options for file format '%s'", fmt);
2606 ret = -1;
2607 goto out;
2608 }
2609
2610 ret = bdrv_amend_options(bs, options_param);
2611 if (ret < 0) {
2612 error_report("Error while amending options: %s", strerror(-ret));
2613 goto out;
2614 }
2615
2616 out:
2617 if (bs) {
2618 bdrv_unref(bs);
2619 }
2620 free_option_parameters(create_options);
2621 free_option_parameters(options_param);
2622 if (ret) {
2623 return 1;
2624 }
2625 return 0;
2626 }
2627
2628 static const img_cmd_t img_cmds[] = {
2629 #define DEF(option, callback, arg_string) \
2630 { option, callback },
2631 #include "qemu-img-cmds.h"
2632 #undef DEF
2633 #undef GEN_DOCS
2634 { NULL, NULL, },
2635 };
2636
2637 int main(int argc, char **argv)
2638 {
2639 const img_cmd_t *cmd;
2640 const char *cmdname;
2641
2642 #ifdef CONFIG_POSIX
2643 signal(SIGPIPE, SIG_IGN);
2644 #endif
2645
2646 error_set_progname(argv[0]);
2647
2648 qemu_init_main_loop();
2649 bdrv_init();
2650 if (argc < 2)
2651 help();
2652 cmdname = argv[1];
2653 argc--; argv++;
2654
2655 /* find the command */
2656 for(cmd = img_cmds; cmd->name != NULL; cmd++) {
2657 if (!strcmp(cmdname, cmd->name)) {
2658 return cmd->handler(argc, argv);
2659 }
2660 }
2661
2662 /* not found */
2663 help();
2664 return 0;
2665 }
QEMU mirror