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