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