?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
lsi: check ssid versus sdid only if ssid is valid
[qemu/ar7.git] / qemu-img.c
blob3e5e388d1ca891fa07c619bfff52c5363f55cf66
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
2010 bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
2011 /* Parse commandline parameters */
2012 for(;;) {
2013 c = getopt(argc, argv, "la:c:d:hq");
2014 if (c == -1) {
2015 break;
2016 }
2017 switch(c) {
2018 case '?':
2019 case 'h':
2020 help();
2021 return 0;
2022 case 'l':
2023 if (action) {
2024 help();
2025 return 0;
2026 }
2027 action = SNAPSHOT_LIST;
2028 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
2029 break;
2030 case 'a':
2031 if (action) {
2032 help();
2033 return 0;
2034 }
2035 action = SNAPSHOT_APPLY;
2036 snapshot_name = optarg;
2037 break;
2038 case 'c':
2039 if (action) {
2040 help();
2041 return 0;
2042 }
2043 action = SNAPSHOT_CREATE;
2044 snapshot_name = optarg;
2045 break;
2046 case 'd':
2047 if (action) {
2048 help();
2049 return 0;
2050 }
2051 action = SNAPSHOT_DELETE;
2052 snapshot_name = optarg;
2053 break;
2054 case 'q':
2055 quiet = true;
2056 break;
2057 }
2058 }
2059
2060 if (optind != argc - 1) {
2061 help();
2062 }
2063 filename = argv[optind++];
2064
2065 /* Open the image */
2066 bs = bdrv_new_open(filename, NULL, bdrv_oflags, true, quiet);
2067 if (!bs) {
2068 return 1;
2069 }
2070
2071 /* Perform the requested action */
2072 switch(action) {
2073 case SNAPSHOT_LIST:
2074 dump_snapshots(bs);
2075 break;
2076
2077 case SNAPSHOT_CREATE:
2078 memset(&sn, 0, sizeof(sn));
2079 pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
2080
2081 qemu_gettimeofday(&tv);
2082 sn.date_sec = tv.tv_sec;
2083 sn.date_nsec = tv.tv_usec * 1000;
2084
2085 ret = bdrv_snapshot_create(bs, &sn);
2086 if (ret) {
2087 error_report("Could not create snapshot '%s': %d (%s)",
2088 snapshot_name, ret, strerror(-ret));
2089 }
2090 break;
2091
2092 case SNAPSHOT_APPLY:
2093 ret = bdrv_snapshot_goto(bs, snapshot_name);
2094 if (ret) {
2095 error_report("Could not apply snapshot '%s': %d (%s)",
2096 snapshot_name, ret, strerror(-ret));
2097 }
2098 break;
2099
2100 case SNAPSHOT_DELETE:
2101 ret = bdrv_snapshot_delete(bs, snapshot_name);
2102 if (ret) {
2103 error_report("Could not delete snapshot '%s': %d (%s)",
2104 snapshot_name, ret, strerror(-ret));
2105 }
2106 break;
2107 }
2108
2109 /* Cleanup */
2110 bdrv_unref(bs);
2111 if (ret) {
2112 return 1;
2113 }
2114 return 0;
2115 }
2116
2117 static int img_rebase(int argc, char **argv)
2118 {
2119 BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
2120 BlockDriver *old_backing_drv, *new_backing_drv;
2121 char *filename;
2122 const char *fmt, *cache, *out_basefmt, *out_baseimg;
2123 int c, flags, ret;
2124 int unsafe = 0;
2125 int progress = 0;
2126 bool quiet = false;
2127
2128 /* Parse commandline parameters */
2129 fmt = NULL;
2130 cache = BDRV_DEFAULT_CACHE;
2131 out_baseimg = NULL;
2132 out_basefmt = NULL;
2133 for(;;) {
2134 c = getopt(argc, argv, "uhf:F:b:pt:q");
2135 if (c == -1) {
2136 break;
2137 }
2138 switch(c) {
2139 case '?':
2140 case 'h':
2141 help();
2142 return 0;
2143 case 'f':
2144 fmt = optarg;
2145 break;
2146 case 'F':
2147 out_basefmt = optarg;
2148 break;
2149 case 'b':
2150 out_baseimg = optarg;
2151 break;
2152 case 'u':
2153 unsafe = 1;
2154 break;
2155 case 'p':
2156 progress = 1;
2157 break;
2158 case 't':
2159 cache = optarg;
2160 break;
2161 case 'q':
2162 quiet = true;
2163 break;
2164 }
2165 }
2166
2167 if (quiet) {
2168 progress = 0;
2169 }
2170
2171 if ((optind != argc - 1) || (!unsafe && !out_baseimg)) {
2172 help();
2173 }
2174 filename = argv[optind++];
2175
2176 qemu_progress_init(progress, 2.0);
2177 qemu_progress_print(0, 100);
2178
2179 flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
2180 ret = bdrv_parse_cache_flags(cache, &flags);
2181 if (ret < 0) {
2182 error_report("Invalid cache option: %s", cache);
2183 return -1;
2184 }
2185
2186 /*
2187 * Open the images.
2188 *
2189 * Ignore the old backing file for unsafe rebase in case we want to correct
2190 * the reference to a renamed or moved backing file.
2191 */
2192 bs = bdrv_new_open(filename, fmt, flags, true, quiet);
2193 if (!bs) {
2194 return 1;
2195 }
2196
2197 /* Find the right drivers for the backing files */
2198 old_backing_drv = NULL;
2199 new_backing_drv = NULL;
2200
2201 if (!unsafe && bs->backing_format[0] != '\0') {
2202 old_backing_drv = bdrv_find_format(bs->backing_format);
2203 if (old_backing_drv == NULL) {
2204 error_report("Invalid format name: '%s'", bs->backing_format);
2205 ret = -1;
2206 goto out;
2207 }
2208 }
2209
2210 if (out_basefmt != NULL) {
2211 new_backing_drv = bdrv_find_format(out_basefmt);
2212 if (new_backing_drv == NULL) {
2213 error_report("Invalid format name: '%s'", out_basefmt);
2214 ret = -1;
2215 goto out;
2216 }
2217 }
2218
2219 /* For safe rebasing we need to compare old and new backing file */
2220 if (unsafe) {
2221 /* Make the compiler happy */
2222 bs_old_backing = NULL;
2223 bs_new_backing = NULL;
2224 } else {
2225 char backing_name[1024];
2226
2227 bs_old_backing = bdrv_new("old_backing");
2228 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
2229 ret = bdrv_open(bs_old_backing, backing_name, NULL, BDRV_O_FLAGS,
2230 old_backing_drv);
2231 if (ret) {
2232 error_report("Could not open old backing file '%s'", backing_name);
2233 goto out;
2234 }
2235 if (out_baseimg[0]) {
2236 bs_new_backing = bdrv_new("new_backing");
2237 ret = bdrv_open(bs_new_backing, out_baseimg, NULL, BDRV_O_FLAGS,
2238 new_backing_drv);
2239 if (ret) {
2240 error_report("Could not open new backing file '%s'",
2241 out_baseimg);
2242 goto out;
2243 }
2244 }
2245 }
2246
2247 /*
2248 * Check each unallocated cluster in the COW file. If it is unallocated,
2249 * accesses go to the backing file. We must therefore compare this cluster
2250 * in the old and new backing file, and if they differ we need to copy it
2251 * from the old backing file into the COW file.
2252 *
2253 * If qemu-img crashes during this step, no harm is done. The content of
2254 * the image is the same as the original one at any time.
2255 */
2256 if (!unsafe) {
2257 uint64_t num_sectors;
2258 uint64_t old_backing_num_sectors;
2259 uint64_t new_backing_num_sectors = 0;
2260 uint64_t sector;
2261 int n;
2262 uint8_t * buf_old;
2263 uint8_t * buf_new;
2264 float local_progress = 0;
2265
2266 buf_old = qemu_blockalign(bs, IO_BUF_SIZE);
2267 buf_new = qemu_blockalign(bs, IO_BUF_SIZE);
2268
2269 bdrv_get_geometry(bs, &num_sectors);
2270 bdrv_get_geometry(bs_old_backing, &old_backing_num_sectors);
2271 if (bs_new_backing) {
2272 bdrv_get_geometry(bs_new_backing, &new_backing_num_sectors);
2273 }
2274
2275 if (num_sectors != 0) {
2276 local_progress = (float)100 /
2277 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
2278 }
2279
2280 for (sector = 0; sector < num_sectors; sector += n) {
2281
2282 /* How many sectors can we handle with the next read? */
2283 if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
2284 n = (IO_BUF_SIZE / 512);
2285 } else {
2286 n = num_sectors - sector;
2287 }
2288
2289 /* If the cluster is allocated, we don't need to take action */
2290 ret = bdrv_is_allocated(bs, sector, n, &n);
2291 if (ret < 0) {
2292 error_report("error while reading image metadata: %s",
2293 strerror(-ret));
2294 goto out;
2295 }
2296 if (ret) {
2297 continue;
2298 }
2299
2300 /*
2301 * Read old and new backing file and take into consideration that
2302 * backing files may be smaller than the COW image.
2303 */
2304 if (sector >= old_backing_num_sectors) {
2305 memset(buf_old, 0, n * BDRV_SECTOR_SIZE);
2306 } else {
2307 if (sector + n > old_backing_num_sectors) {
2308 n = old_backing_num_sectors - sector;
2309 }
2310
2311 ret = bdrv_read(bs_old_backing, sector, buf_old, n);
2312 if (ret < 0) {
2313 error_report("error while reading from old backing file");
2314 goto out;
2315 }
2316 }
2317
2318 if (sector >= new_backing_num_sectors || !bs_new_backing) {
2319 memset(buf_new, 0, n * BDRV_SECTOR_SIZE);
2320 } else {
2321 if (sector + n > new_backing_num_sectors) {
2322 n = new_backing_num_sectors - sector;
2323 }
2324
2325 ret = bdrv_read(bs_new_backing, sector, buf_new, n);
2326 if (ret < 0) {
2327 error_report("error while reading from new backing file");
2328 goto out;
2329 }
2330 }
2331
2332 /* If they differ, we need to write to the COW file */
2333 uint64_t written = 0;
2334
2335 while (written < n) {
2336 int pnum;
2337
2338 if (compare_sectors(buf_old + written * 512,
2339 buf_new + written * 512, n - written, &pnum))
2340 {
2341 ret = bdrv_write(bs, sector + written,
2342 buf_old + written * 512, pnum);
2343 if (ret < 0) {
2344 error_report("Error while writing to COW image: %s",
2345 strerror(-ret));
2346 goto out;
2347 }
2348 }
2349
2350 written += pnum;
2351 }
2352 qemu_progress_print(local_progress, 100);
2353 }
2354
2355 qemu_vfree(buf_old);
2356 qemu_vfree(buf_new);
2357 }
2358
2359 /*
2360 * Change the backing file. All clusters that are different from the old
2361 * backing file are overwritten in the COW file now, so the visible content
2362 * doesn't change when we switch the backing file.
2363 */
2364 if (out_baseimg && *out_baseimg) {
2365 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
2366 } else {
2367 ret = bdrv_change_backing_file(bs, NULL, NULL);
2368 }
2369
2370 if (ret == -ENOSPC) {
2371 error_report("Could not change the backing file to '%s': No "
2372 "space left in the file header", out_baseimg);
2373 } else if (ret < 0) {
2374 error_report("Could not change the backing file to '%s': %s",
2375 out_baseimg, strerror(-ret));
2376 }
2377
2378 qemu_progress_print(100, 0);
2379 /*
2380 * TODO At this point it is possible to check if any clusters that are
2381 * allocated in the COW file are the same in the backing file. If so, they
2382 * could be dropped from the COW file. Don't do this before switching the
2383 * backing file, in case of a crash this would lead to corruption.
2384 */
2385 out:
2386 qemu_progress_end();
2387 /* Cleanup */
2388 if (!unsafe) {
2389 if (bs_old_backing != NULL) {
2390 bdrv_unref(bs_old_backing);
2391 }
2392 if (bs_new_backing != NULL) {
2393 bdrv_unref(bs_new_backing);
2394 }
2395 }
2396
2397 bdrv_unref(bs);
2398 if (ret) {
2399 return 1;
2400 }
2401 return 0;
2402 }
2403
2404 static int img_resize(int argc, char **argv)
2405 {
2406 int c, ret, relative;
2407 const char *filename, *fmt, *size;
2408 int64_t n, total_size;
2409 bool quiet = false;
2410 BlockDriverState *bs = NULL;
2411 QemuOpts *param;
2412 static QemuOptsList resize_options = {
2413 .name = "resize_options",
2414 .head = QTAILQ_HEAD_INITIALIZER(resize_options.head),
2415 .desc = {
2416 {
2417 .name = BLOCK_OPT_SIZE,
2418 .type = QEMU_OPT_SIZE,
2419 .help = "Virtual disk size"
2420 }, {
2421 /* end of list */
2422 }
2423 },
2424 };
2425
2426 /* Remove size from argv manually so that negative numbers are not treated
2427 * as options by getopt. */
2428 if (argc < 3) {
2429 help();
2430 return 1;
2431 }
2432
2433 size = argv[--argc];
2434
2435 /* Parse getopt arguments */
2436 fmt = NULL;
2437 for(;;) {
2438 c = getopt(argc, argv, "f:hq");
2439 if (c == -1) {
2440 break;
2441 }
2442 switch(c) {
2443 case '?':
2444 case 'h':
2445 help();
2446 break;
2447 case 'f':
2448 fmt = optarg;
2449 break;
2450 case 'q':
2451 quiet = true;
2452 break;
2453 }
2454 }
2455 if (optind != argc - 1) {
2456 help();
2457 }
2458 filename = argv[optind++];
2459
2460 /* Choose grow, shrink, or absolute resize mode */
2461 switch (size[0]) {
2462 case '+':
2463 relative = 1;
2464 size++;
2465 break;
2466 case '-':
2467 relative = -1;
2468 size++;
2469 break;
2470 default:
2471 relative = 0;
2472 break;
2473 }
2474
2475 /* Parse size */
2476 param = qemu_opts_create_nofail(&resize_options);
2477 if (qemu_opt_set(param, BLOCK_OPT_SIZE, size)) {
2478 /* Error message already printed when size parsing fails */
2479 ret = -1;
2480 qemu_opts_del(param);
2481 goto out;
2482 }
2483 n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
2484 qemu_opts_del(param);
2485
2486 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR, true, quiet);
2487 if (!bs) {
2488 ret = -1;
2489 goto out;
2490 }
2491
2492 if (relative) {
2493 total_size = bdrv_getlength(bs) + n * relative;
2494 } else {
2495 total_size = n;
2496 }
2497 if (total_size <= 0) {
2498 error_report("New image size must be positive");
2499 ret = -1;
2500 goto out;
2501 }
2502
2503 ret = bdrv_truncate(bs, total_size);
2504 switch (ret) {
2505 case 0:
2506 qprintf(quiet, "Image resized.\n");
2507 break;
2508 case -ENOTSUP:
2509 error_report("This image does not support resize");
2510 break;
2511 case -EACCES:
2512 error_report("Image is read-only");
2513 break;
2514 default:
2515 error_report("Error resizing image (%d)", -ret);
2516 break;
2517 }
2518 out:
2519 if (bs) {
2520 bdrv_unref(bs);
2521 }
2522 if (ret) {
2523 return 1;
2524 }
2525 return 0;
2526 }
2527
2528 static const img_cmd_t img_cmds[] = {
2529 #define DEF(option, callback, arg_string) \
2530 { option, callback },
2531 #include "qemu-img-cmds.h"
2532 #undef DEF
2533 #undef GEN_DOCS
2534 { NULL, NULL, },
2535 };
2536
2537 int main(int argc, char **argv)
2538 {
2539 const img_cmd_t *cmd;
2540 const char *cmdname;
2541
2542 #ifdef CONFIG_POSIX
2543 signal(SIGPIPE, SIG_IGN);
2544 #endif
2545
2546 error_set_progname(argv[0]);
2547
2548 qemu_init_main_loop();
2549 bdrv_init();
2550 if (argc < 2)
2551 help();
2552 cmdname = argv[1];
2553 argc--; argv++;
2554
2555 /* find the command */
2556 for(cmd = img_cmds; cmd->name != NULL; cmd++) {
2557 if (!strcmp(cmdname, cmd->name)) {
2558 return cmd->handler(argc, argv);
2559 }
2560 }
2561
2562 /* not found */
2563 help();
2564 return 0;
2565 }
AR7 emulation for QEMU