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