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