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