buffer: add buffer_shrink
[qemu/ar7.git] / qemu-img.c
blob3025776e14c9b40cd59370954b2050dbd4b93b73
1 /*
2 * QEMU disk image utility
4 * Copyright (c) 2003-2008 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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.
24 #include "qapi-visit.h"
25 #include "qapi/qmp-output-visitor.h"
26 #include "qapi/qmp/qerror.h"
27 #include "qapi/qmp/qjson.h"
28 #include "qemu-common.h"
29 #include "qemu/option.h"
30 #include "qemu/error-report.h"
31 #include "qemu/osdep.h"
32 #include "sysemu/sysemu.h"
33 #include "sysemu/block-backend.h"
34 #include "block/block_int.h"
35 #include "block/blockjob.h"
36 #include "block/qapi.h"
37 #include <getopt.h>
39 #define QEMU_IMG_VERSION "qemu-img version " QEMU_VERSION QEMU_PKGVERSION \
40 ", Copyright (c) 2004-2008 Fabrice Bellard\n"
42 typedef struct img_cmd_t {
43 const char *name;
44 int (*handler)(int argc, char **argv);
45 } img_cmd_t;
47 enum {
48 OPTION_OUTPUT = 256,
49 OPTION_BACKING_CHAIN = 257,
52 typedef enum OutputFormat {
53 OFORMAT_JSON,
54 OFORMAT_HUMAN,
55 } OutputFormat;
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"
61 static void format_print(void *opaque, const char *name)
63 printf(" %s", name);
66 static void QEMU_NORETURN GCC_FMT_ATTR(1, 2) error_exit(const char *fmt, ...)
68 va_list ap;
70 error_printf("qemu-img: ");
72 va_start(ap, fmt);
73 error_vprintf(fmt, ap);
74 va_end(ap);
76 error_printf("\nTry 'qemu-img --help' for more information\n");
77 exit(EXIT_FAILURE);
80 /* Please keep in synch with qemu-img.texi */
81 static void QEMU_NORETURN help(void)
83 const char *help_msg =
84 QEMU_IMG_VERSION
85 "usage: qemu-img command [command options]\n"
86 "QEMU disk image utility\n"
87 "\n"
88 "Command syntax:\n"
89 #define DEF(option, callback, arg_string) \
90 " " arg_string "\n"
91 #include "qemu-img-cmds.h"
92 #undef DEF
93 #undef GEN_DOCS
94 "\n"
95 "Command parameters:\n"
96 " 'filename' is a disk image filename\n"
97 " 'fmt' is the disk image format. It is guessed automatically in most cases\n"
98 " 'cache' is the cache mode used to write the output disk image, the valid\n"
99 " options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n"
100 " 'directsync' and 'unsafe' (default for convert)\n"
101 " 'src_cache' is the cache mode used to read input disk images, the valid\n"
102 " options are the same as for the 'cache' option\n"
103 " 'size' is the disk image size in bytes. Optional suffixes\n"
104 " 'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M),\n"
105 " 'T' (terabyte, 1024G), 'P' (petabyte, 1024T) and 'E' (exabyte, 1024P) are\n"
106 " supported. 'b' is ignored.\n"
107 " 'output_filename' is the destination disk image filename\n"
108 " 'output_fmt' is the destination format\n"
109 " 'options' is a comma separated list of format specific options in a\n"
110 " name=value format. Use -o ? for an overview of the options supported by the\n"
111 " used format\n"
112 " 'snapshot_param' is param used for internal snapshot, format\n"
113 " is 'snapshot.id=[ID],snapshot.name=[NAME]', or\n"
114 " '[ID_OR_NAME]'\n"
115 " 'snapshot_id_or_name' is deprecated, use 'snapshot_param'\n"
116 " instead\n"
117 " '-c' indicates that target image must be compressed (qcow format only)\n"
118 " '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
119 " match exactly. The image doesn't need a working backing file before\n"
120 " rebasing in this case (useful for renaming the backing file)\n"
121 " '-h' with or without a command shows this help and lists the supported formats\n"
122 " '-p' show progress of command (only certain commands)\n"
123 " '-q' use Quiet mode - do not print any output (except errors)\n"
124 " '-S' indicates the consecutive number of bytes (defaults to 4k) that must\n"
125 " contain only zeros for qemu-img to create a sparse image during\n"
126 " conversion. If the number of bytes is 0, the source will not be scanned for\n"
127 " unallocated or zero sectors, and the destination image will always be\n"
128 " fully allocated\n"
129 " '--output' takes the format in which the output must be done (human or json)\n"
130 " '-n' skips the target volume creation (useful if the volume is created\n"
131 " prior to running qemu-img)\n"
132 "\n"
133 "Parameters to check subcommand:\n"
134 " '-r' tries to repair any inconsistencies that are found during the check.\n"
135 " '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n"
136 " kinds of errors, with a higher risk of choosing the wrong fix or\n"
137 " hiding corruption that has already occurred.\n"
138 "\n"
139 "Parameters to snapshot subcommand:\n"
140 " 'snapshot' is the name of the snapshot to create, apply or delete\n"
141 " '-a' applies a snapshot (revert disk to saved state)\n"
142 " '-c' creates a snapshot\n"
143 " '-d' deletes a snapshot\n"
144 " '-l' lists all snapshots in the given image\n"
145 "\n"
146 "Parameters to compare subcommand:\n"
147 " '-f' first image format\n"
148 " '-F' second image format\n"
149 " '-s' run in Strict mode - fail on different image size or sector allocation\n";
151 printf("%s\nSupported formats:", help_msg);
152 bdrv_iterate_format(format_print, NULL);
153 printf("\n");
154 exit(EXIT_SUCCESS);
157 static int GCC_FMT_ATTR(2, 3) qprintf(bool quiet, const char *fmt, ...)
159 int ret = 0;
160 if (!quiet) {
161 va_list args;
162 va_start(args, fmt);
163 ret = vprintf(fmt, args);
164 va_end(args);
166 return ret;
170 static int print_block_option_help(const char *filename, const char *fmt)
172 BlockDriver *drv, *proto_drv;
173 QemuOptsList *create_opts = NULL;
174 Error *local_err = NULL;
176 /* Find driver and parse its options */
177 drv = bdrv_find_format(fmt);
178 if (!drv) {
179 error_report("Unknown file format '%s'", fmt);
180 return 1;
183 create_opts = qemu_opts_append(create_opts, drv->create_opts);
184 if (filename) {
185 proto_drv = bdrv_find_protocol(filename, true, &local_err);
186 if (!proto_drv) {
187 error_report_err(local_err);
188 qemu_opts_free(create_opts);
189 return 1;
191 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
194 qemu_opts_print_help(create_opts);
195 qemu_opts_free(create_opts);
196 return 0;
199 static BlockBackend *img_open(const char *id, const char *filename,
200 const char *fmt, int flags,
201 bool require_io, bool quiet)
203 BlockBackend *blk;
204 BlockDriverState *bs;
205 char password[256];
206 Error *local_err = NULL;
207 QDict *options = NULL;
209 if (fmt) {
210 options = qdict_new();
211 qdict_put(options, "driver", qstring_from_str(fmt));
214 blk = blk_new_open(id, filename, NULL, options, flags, &local_err);
215 if (!blk) {
216 error_report("Could not open '%s': %s", filename,
217 error_get_pretty(local_err));
218 error_free(local_err);
219 goto fail;
222 bs = blk_bs(blk);
223 if (bdrv_is_encrypted(bs) && require_io) {
224 qprintf(quiet, "Disk image '%s' is encrypted.\n", filename);
225 if (qemu_read_password(password, sizeof(password)) < 0) {
226 error_report("No password given");
227 goto fail;
229 if (bdrv_set_key(bs, password) < 0) {
230 error_report("invalid password");
231 goto fail;
234 return blk;
235 fail:
236 blk_unref(blk);
237 return NULL;
240 static int add_old_style_options(const char *fmt, QemuOpts *opts,
241 const char *base_filename,
242 const char *base_fmt)
244 Error *err = NULL;
246 if (base_filename) {
247 qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &err);
248 if (err) {
249 error_report("Backing file not supported for file format '%s'",
250 fmt);
251 error_free(err);
252 return -1;
255 if (base_fmt) {
256 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &err);
257 if (err) {
258 error_report("Backing file format not supported for file "
259 "format '%s'", fmt);
260 error_free(err);
261 return -1;
264 return 0;
267 static int img_create(int argc, char **argv)
269 int c;
270 uint64_t img_size = -1;
271 const char *fmt = "raw";
272 const char *base_fmt = NULL;
273 const char *filename;
274 const char *base_filename = NULL;
275 char *options = NULL;
276 Error *local_err = NULL;
277 bool quiet = false;
279 for(;;) {
280 c = getopt(argc, argv, "F:b:f:he6o:q");
281 if (c == -1) {
282 break;
284 switch(c) {
285 case '?':
286 case 'h':
287 help();
288 break;
289 case 'F':
290 base_fmt = optarg;
291 break;
292 case 'b':
293 base_filename = optarg;
294 break;
295 case 'f':
296 fmt = optarg;
297 break;
298 case 'e':
299 error_report("option -e is deprecated, please use \'-o "
300 "encryption\' instead!");
301 goto fail;
302 case '6':
303 error_report("option -6 is deprecated, please use \'-o "
304 "compat6\' instead!");
305 goto fail;
306 case 'o':
307 if (!is_valid_option_list(optarg)) {
308 error_report("Invalid option list: %s", optarg);
309 goto fail;
311 if (!options) {
312 options = g_strdup(optarg);
313 } else {
314 char *old_options = options;
315 options = g_strdup_printf("%s,%s", options, optarg);
316 g_free(old_options);
318 break;
319 case 'q':
320 quiet = true;
321 break;
325 /* Get the filename */
326 filename = (optind < argc) ? argv[optind] : NULL;
327 if (options && has_help_option(options)) {
328 g_free(options);
329 return print_block_option_help(filename, fmt);
332 if (optind >= argc) {
333 error_exit("Expecting image file name");
335 optind++;
337 /* Get image size, if specified */
338 if (optind < argc) {
339 int64_t sval;
340 char *end;
341 sval = qemu_strtosz_suffix(argv[optind++], &end,
342 QEMU_STRTOSZ_DEFSUFFIX_B);
343 if (sval < 0 || *end) {
344 if (sval == -ERANGE) {
345 error_report("Image size must be less than 8 EiB!");
346 } else {
347 error_report("Invalid image size specified! You may use k, M, "
348 "G, T, P or E suffixes for ");
349 error_report("kilobytes, megabytes, gigabytes, terabytes, "
350 "petabytes and exabytes.");
352 goto fail;
354 img_size = (uint64_t)sval;
356 if (optind != argc) {
357 error_exit("Unexpected argument: %s", argv[optind]);
360 bdrv_img_create(filename, fmt, base_filename, base_fmt,
361 options, img_size, BDRV_O_FLAGS, &local_err, quiet);
362 if (local_err) {
363 error_report("%s: %s", filename, error_get_pretty(local_err));
364 error_free(local_err);
365 goto fail;
368 g_free(options);
369 return 0;
371 fail:
372 g_free(options);
373 return 1;
376 static void dump_json_image_check(ImageCheck *check, bool quiet)
378 Error *local_err = NULL;
379 QString *str;
380 QmpOutputVisitor *ov = qmp_output_visitor_new();
381 QObject *obj;
382 visit_type_ImageCheck(qmp_output_get_visitor(ov),
383 &check, NULL, &local_err);
384 obj = qmp_output_get_qobject(ov);
385 str = qobject_to_json_pretty(obj);
386 assert(str != NULL);
387 qprintf(quiet, "%s\n", qstring_get_str(str));
388 qobject_decref(obj);
389 qmp_output_visitor_cleanup(ov);
390 QDECREF(str);
393 static void dump_human_image_check(ImageCheck *check, bool quiet)
395 if (!(check->corruptions || check->leaks || check->check_errors)) {
396 qprintf(quiet, "No errors were found on the image.\n");
397 } else {
398 if (check->corruptions) {
399 qprintf(quiet, "\n%" PRId64 " errors were found on the image.\n"
400 "Data may be corrupted, or further writes to the image "
401 "may corrupt it.\n",
402 check->corruptions);
405 if (check->leaks) {
406 qprintf(quiet,
407 "\n%" PRId64 " leaked clusters were found on the image.\n"
408 "This means waste of disk space, but no harm to data.\n",
409 check->leaks);
412 if (check->check_errors) {
413 qprintf(quiet,
414 "\n%" PRId64
415 " internal errors have occurred during the check.\n",
416 check->check_errors);
420 if (check->total_clusters != 0 && check->allocated_clusters != 0) {
421 qprintf(quiet, "%" PRId64 "/%" PRId64 " = %0.2f%% allocated, "
422 "%0.2f%% fragmented, %0.2f%% compressed clusters\n",
423 check->allocated_clusters, check->total_clusters,
424 check->allocated_clusters * 100.0 / check->total_clusters,
425 check->fragmented_clusters * 100.0 / check->allocated_clusters,
426 check->compressed_clusters * 100.0 /
427 check->allocated_clusters);
430 if (check->image_end_offset) {
431 qprintf(quiet,
432 "Image end offset: %" PRId64 "\n", check->image_end_offset);
436 static int collect_image_check(BlockDriverState *bs,
437 ImageCheck *check,
438 const char *filename,
439 const char *fmt,
440 int fix)
442 int ret;
443 BdrvCheckResult result;
445 ret = bdrv_check(bs, &result, fix);
446 if (ret < 0) {
447 return ret;
450 check->filename = g_strdup(filename);
451 check->format = g_strdup(bdrv_get_format_name(bs));
452 check->check_errors = result.check_errors;
453 check->corruptions = result.corruptions;
454 check->has_corruptions = result.corruptions != 0;
455 check->leaks = result.leaks;
456 check->has_leaks = result.leaks != 0;
457 check->corruptions_fixed = result.corruptions_fixed;
458 check->has_corruptions_fixed = result.corruptions != 0;
459 check->leaks_fixed = result.leaks_fixed;
460 check->has_leaks_fixed = result.leaks != 0;
461 check->image_end_offset = result.image_end_offset;
462 check->has_image_end_offset = result.image_end_offset != 0;
463 check->total_clusters = result.bfi.total_clusters;
464 check->has_total_clusters = result.bfi.total_clusters != 0;
465 check->allocated_clusters = result.bfi.allocated_clusters;
466 check->has_allocated_clusters = result.bfi.allocated_clusters != 0;
467 check->fragmented_clusters = result.bfi.fragmented_clusters;
468 check->has_fragmented_clusters = result.bfi.fragmented_clusters != 0;
469 check->compressed_clusters = result.bfi.compressed_clusters;
470 check->has_compressed_clusters = result.bfi.compressed_clusters != 0;
472 return 0;
476 * Checks an image for consistency. Exit codes:
478 * 0 - Check completed, image is good
479 * 1 - Check not completed because of internal errors
480 * 2 - Check completed, image is corrupted
481 * 3 - Check completed, image has leaked clusters, but is good otherwise
482 * 63 - Checks are not supported by the image format
484 static int img_check(int argc, char **argv)
486 int c, ret;
487 OutputFormat output_format = OFORMAT_HUMAN;
488 const char *filename, *fmt, *output, *cache;
489 BlockBackend *blk;
490 BlockDriverState *bs;
491 int fix = 0;
492 int flags = BDRV_O_FLAGS | BDRV_O_CHECK;
493 ImageCheck *check;
494 bool quiet = false;
496 fmt = NULL;
497 output = NULL;
498 cache = BDRV_DEFAULT_CACHE;
499 for(;;) {
500 int option_index = 0;
501 static const struct option long_options[] = {
502 {"help", no_argument, 0, 'h'},
503 {"format", required_argument, 0, 'f'},
504 {"repair", required_argument, 0, 'r'},
505 {"output", required_argument, 0, OPTION_OUTPUT},
506 {0, 0, 0, 0}
508 c = getopt_long(argc, argv, "hf:r:T:q",
509 long_options, &option_index);
510 if (c == -1) {
511 break;
513 switch(c) {
514 case '?':
515 case 'h':
516 help();
517 break;
518 case 'f':
519 fmt = optarg;
520 break;
521 case 'r':
522 flags |= BDRV_O_RDWR;
524 if (!strcmp(optarg, "leaks")) {
525 fix = BDRV_FIX_LEAKS;
526 } else if (!strcmp(optarg, "all")) {
527 fix = BDRV_FIX_LEAKS | BDRV_FIX_ERRORS;
528 } else {
529 error_exit("Unknown option value for -r "
530 "(expecting 'leaks' or 'all'): %s", optarg);
532 break;
533 case OPTION_OUTPUT:
534 output = optarg;
535 break;
536 case 'T':
537 cache = optarg;
538 break;
539 case 'q':
540 quiet = true;
541 break;
544 if (optind != argc - 1) {
545 error_exit("Expecting one image file name");
547 filename = argv[optind++];
549 if (output && !strcmp(output, "json")) {
550 output_format = OFORMAT_JSON;
551 } else if (output && !strcmp(output, "human")) {
552 output_format = OFORMAT_HUMAN;
553 } else if (output) {
554 error_report("--output must be used with human or json as argument.");
555 return 1;
558 ret = bdrv_parse_cache_flags(cache, &flags);
559 if (ret < 0) {
560 error_report("Invalid source cache option: %s", cache);
561 return 1;
564 blk = img_open("image", filename, fmt, flags, true, quiet);
565 if (!blk) {
566 return 1;
568 bs = blk_bs(blk);
570 check = g_new0(ImageCheck, 1);
571 ret = collect_image_check(bs, check, filename, fmt, fix);
573 if (ret == -ENOTSUP) {
574 error_report("This image format does not support checks");
575 ret = 63;
576 goto fail;
579 if (check->corruptions_fixed || check->leaks_fixed) {
580 int corruptions_fixed, leaks_fixed;
582 leaks_fixed = check->leaks_fixed;
583 corruptions_fixed = check->corruptions_fixed;
585 if (output_format == OFORMAT_HUMAN) {
586 qprintf(quiet,
587 "The following inconsistencies were found and repaired:\n\n"
588 " %" PRId64 " leaked clusters\n"
589 " %" PRId64 " corruptions\n\n"
590 "Double checking the fixed image now...\n",
591 check->leaks_fixed,
592 check->corruptions_fixed);
595 ret = collect_image_check(bs, check, filename, fmt, 0);
597 check->leaks_fixed = leaks_fixed;
598 check->corruptions_fixed = corruptions_fixed;
601 if (!ret) {
602 switch (output_format) {
603 case OFORMAT_HUMAN:
604 dump_human_image_check(check, quiet);
605 break;
606 case OFORMAT_JSON:
607 dump_json_image_check(check, quiet);
608 break;
612 if (ret || check->check_errors) {
613 if (ret) {
614 error_report("Check failed: %s", strerror(-ret));
615 } else {
616 error_report("Check failed");
618 ret = 1;
619 goto fail;
622 if (check->corruptions) {
623 ret = 2;
624 } else if (check->leaks) {
625 ret = 3;
626 } else {
627 ret = 0;
630 fail:
631 qapi_free_ImageCheck(check);
632 blk_unref(blk);
633 return ret;
636 typedef struct CommonBlockJobCBInfo {
637 BlockDriverState *bs;
638 Error **errp;
639 } CommonBlockJobCBInfo;
641 static void common_block_job_cb(void *opaque, int ret)
643 CommonBlockJobCBInfo *cbi = opaque;
645 if (ret < 0) {
646 error_setg_errno(cbi->errp, -ret, "Block job failed");
649 /* Drop this block job's reference */
650 bdrv_unref(cbi->bs);
653 static void run_block_job(BlockJob *job, Error **errp)
655 AioContext *aio_context = bdrv_get_aio_context(job->bs);
657 do {
658 aio_poll(aio_context, true);
659 qemu_progress_print((float)job->offset / job->len * 100.f, 0);
660 } while (!job->ready);
662 block_job_complete_sync(job, errp);
664 /* A block job may finish instantaneously without publishing any progress,
665 * so just signal completion here */
666 qemu_progress_print(100.f, 0);
669 static int img_commit(int argc, char **argv)
671 int c, ret, flags;
672 const char *filename, *fmt, *cache, *base;
673 BlockBackend *blk;
674 BlockDriverState *bs, *base_bs;
675 bool progress = false, quiet = false, drop = false;
676 Error *local_err = NULL;
677 CommonBlockJobCBInfo cbi;
679 fmt = NULL;
680 cache = BDRV_DEFAULT_CACHE;
681 base = NULL;
682 for(;;) {
683 c = getopt(argc, argv, "f:ht:b:dpq");
684 if (c == -1) {
685 break;
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 'b':
699 base = optarg;
700 /* -b implies -d */
701 drop = true;
702 break;
703 case 'd':
704 drop = true;
705 break;
706 case 'p':
707 progress = true;
708 break;
709 case 'q':
710 quiet = true;
711 break;
715 /* Progress is not shown in Quiet mode */
716 if (quiet) {
717 progress = false;
720 if (optind != argc - 1) {
721 error_exit("Expecting one image file name");
723 filename = argv[optind++];
725 flags = BDRV_O_RDWR | BDRV_O_UNMAP;
726 ret = bdrv_parse_cache_flags(cache, &flags);
727 if (ret < 0) {
728 error_report("Invalid cache option: %s", cache);
729 return 1;
732 blk = img_open("image", filename, fmt, flags, true, quiet);
733 if (!blk) {
734 return 1;
736 bs = blk_bs(blk);
738 qemu_progress_init(progress, 1.f);
739 qemu_progress_print(0.f, 100);
741 if (base) {
742 base_bs = bdrv_find_backing_image(bs, base);
743 if (!base_bs) {
744 error_setg(&local_err, QERR_BASE_NOT_FOUND, base);
745 goto done;
747 } else {
748 /* This is different from QMP, which by default uses the deepest file in
749 * the backing chain (i.e., the very base); however, the traditional
750 * behavior of qemu-img commit is using the immediate backing file. */
751 base_bs = backing_bs(bs);
752 if (!base_bs) {
753 error_setg(&local_err, "Image does not have a backing file");
754 goto done;
758 cbi = (CommonBlockJobCBInfo){
759 .errp = &local_err,
760 .bs = bs,
763 commit_active_start(bs, base_bs, 0, BLOCKDEV_ON_ERROR_REPORT,
764 common_block_job_cb, &cbi, &local_err);
765 if (local_err) {
766 goto done;
769 /* When the block job completes, the BlockBackend reference will point to
770 * the old backing file. In order to avoid that the top image is already
771 * deleted, so we can still empty it afterwards, increment the reference
772 * counter here preemptively. */
773 if (!drop) {
774 bdrv_ref(bs);
777 run_block_job(bs->job, &local_err);
778 if (local_err) {
779 goto unref_backing;
782 if (!drop && bs->drv->bdrv_make_empty) {
783 ret = bs->drv->bdrv_make_empty(bs);
784 if (ret) {
785 error_setg_errno(&local_err, -ret, "Could not empty %s",
786 filename);
787 goto unref_backing;
791 unref_backing:
792 if (!drop) {
793 bdrv_unref(bs);
796 done:
797 qemu_progress_end();
799 blk_unref(blk);
801 if (local_err) {
802 error_report_err(local_err);
803 return 1;
806 qprintf(quiet, "Image committed.\n");
807 return 0;
811 * Returns true iff the first sector pointed to by 'buf' contains at least
812 * a non-NUL byte.
814 * 'pnum' is set to the number of sectors (including and immediately following
815 * the first one) that are known to be in the same allocated/unallocated state.
817 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
819 bool is_zero;
820 int i;
822 if (n <= 0) {
823 *pnum = 0;
824 return 0;
826 is_zero = buffer_is_zero(buf, 512);
827 for(i = 1; i < n; i++) {
828 buf += 512;
829 if (is_zero != buffer_is_zero(buf, 512)) {
830 break;
833 *pnum = i;
834 return !is_zero;
838 * Like is_allocated_sectors, but if the buffer starts with a used sector,
839 * up to 'min' consecutive sectors containing zeros are ignored. This avoids
840 * breaking up write requests for only small sparse areas.
842 static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
843 int min)
845 int ret;
846 int num_checked, num_used;
848 if (n < min) {
849 min = n;
852 ret = is_allocated_sectors(buf, n, pnum);
853 if (!ret) {
854 return ret;
857 num_used = *pnum;
858 buf += BDRV_SECTOR_SIZE * *pnum;
859 n -= *pnum;
860 num_checked = num_used;
862 while (n > 0) {
863 ret = is_allocated_sectors(buf, n, pnum);
865 buf += BDRV_SECTOR_SIZE * *pnum;
866 n -= *pnum;
867 num_checked += *pnum;
868 if (ret) {
869 num_used = num_checked;
870 } else if (*pnum >= min) {
871 break;
875 *pnum = num_used;
876 return 1;
880 * Compares two buffers sector by sector. Returns 0 if the first sector of both
881 * buffers matches, non-zero otherwise.
883 * pnum is set to the number of sectors (including and immediately following
884 * the first one) that are known to have the same comparison result
886 static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
887 int *pnum)
889 bool res;
890 int i;
892 if (n <= 0) {
893 *pnum = 0;
894 return 0;
897 res = !!memcmp(buf1, buf2, 512);
898 for(i = 1; i < n; i++) {
899 buf1 += 512;
900 buf2 += 512;
902 if (!!memcmp(buf1, buf2, 512) != res) {
903 break;
907 *pnum = i;
908 return res;
911 #define IO_BUF_SIZE (2 * 1024 * 1024)
913 static int64_t sectors_to_bytes(int64_t sectors)
915 return sectors << BDRV_SECTOR_BITS;
918 static int64_t sectors_to_process(int64_t total, int64_t from)
920 return MIN(total - from, IO_BUF_SIZE >> BDRV_SECTOR_BITS);
924 * Check if passed sectors are empty (not allocated or contain only 0 bytes)
926 * Returns 0 in case sectors are filled with 0, 1 if sectors contain non-zero
927 * data and negative value on error.
929 * @param blk: BlockBackend for the image
930 * @param sect_num: Number of first sector to check
931 * @param sect_count: Number of sectors to check
932 * @param filename: Name of disk file we are checking (logging purpose)
933 * @param buffer: Allocated buffer for storing read data
934 * @param quiet: Flag for quiet mode
936 static int check_empty_sectors(BlockBackend *blk, int64_t sect_num,
937 int sect_count, const char *filename,
938 uint8_t *buffer, bool quiet)
940 int pnum, ret = 0;
941 ret = blk_read(blk, sect_num, buffer, sect_count);
942 if (ret < 0) {
943 error_report("Error while reading offset %" PRId64 " of %s: %s",
944 sectors_to_bytes(sect_num), filename, strerror(-ret));
945 return ret;
947 ret = is_allocated_sectors(buffer, sect_count, &pnum);
948 if (ret || pnum != sect_count) {
949 qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
950 sectors_to_bytes(ret ? sect_num : sect_num + pnum));
951 return 1;
954 return 0;
958 * Compares two images. Exit codes:
960 * 0 - Images are identical
961 * 1 - Images differ
962 * >1 - Error occurred
964 static int img_compare(int argc, char **argv)
966 const char *fmt1 = NULL, *fmt2 = NULL, *cache, *filename1, *filename2;
967 BlockBackend *blk1, *blk2;
968 BlockDriverState *bs1, *bs2;
969 int64_t total_sectors1, total_sectors2;
970 uint8_t *buf1 = NULL, *buf2 = NULL;
971 int pnum1, pnum2;
972 int allocated1, allocated2;
973 int ret = 0; /* return value - 0 Ident, 1 Different, >1 Error */
974 bool progress = false, quiet = false, strict = false;
975 int flags;
976 int64_t total_sectors;
977 int64_t sector_num = 0;
978 int64_t nb_sectors;
979 int c, pnum;
980 uint64_t progress_base;
982 cache = BDRV_DEFAULT_CACHE;
983 for (;;) {
984 c = getopt(argc, argv, "hf:F:T:pqs");
985 if (c == -1) {
986 break;
988 switch (c) {
989 case '?':
990 case 'h':
991 help();
992 break;
993 case 'f':
994 fmt1 = optarg;
995 break;
996 case 'F':
997 fmt2 = optarg;
998 break;
999 case 'T':
1000 cache = optarg;
1001 break;
1002 case 'p':
1003 progress = true;
1004 break;
1005 case 'q':
1006 quiet = true;
1007 break;
1008 case 's':
1009 strict = true;
1010 break;
1014 /* Progress is not shown in Quiet mode */
1015 if (quiet) {
1016 progress = false;
1020 if (optind != argc - 2) {
1021 error_exit("Expecting two image file names");
1023 filename1 = argv[optind++];
1024 filename2 = argv[optind++];
1026 /* Initialize before goto out */
1027 qemu_progress_init(progress, 2.0);
1029 flags = BDRV_O_FLAGS;
1030 ret = bdrv_parse_cache_flags(cache, &flags);
1031 if (ret < 0) {
1032 error_report("Invalid source cache option: %s", cache);
1033 ret = 2;
1034 goto out3;
1037 blk1 = img_open("image_1", filename1, fmt1, flags, true, quiet);
1038 if (!blk1) {
1039 ret = 2;
1040 goto out3;
1042 bs1 = blk_bs(blk1);
1044 blk2 = img_open("image_2", filename2, fmt2, flags, true, quiet);
1045 if (!blk2) {
1046 ret = 2;
1047 goto out2;
1049 bs2 = blk_bs(blk2);
1051 buf1 = blk_blockalign(blk1, IO_BUF_SIZE);
1052 buf2 = blk_blockalign(blk2, IO_BUF_SIZE);
1053 total_sectors1 = blk_nb_sectors(blk1);
1054 if (total_sectors1 < 0) {
1055 error_report("Can't get size of %s: %s",
1056 filename1, strerror(-total_sectors1));
1057 ret = 4;
1058 goto out;
1060 total_sectors2 = blk_nb_sectors(blk2);
1061 if (total_sectors2 < 0) {
1062 error_report("Can't get size of %s: %s",
1063 filename2, strerror(-total_sectors2));
1064 ret = 4;
1065 goto out;
1067 total_sectors = MIN(total_sectors1, total_sectors2);
1068 progress_base = MAX(total_sectors1, total_sectors2);
1070 qemu_progress_print(0, 100);
1072 if (strict && total_sectors1 != total_sectors2) {
1073 ret = 1;
1074 qprintf(quiet, "Strict mode: Image size mismatch!\n");
1075 goto out;
1078 for (;;) {
1079 nb_sectors = sectors_to_process(total_sectors, sector_num);
1080 if (nb_sectors <= 0) {
1081 break;
1083 allocated1 = bdrv_is_allocated_above(bs1, NULL, sector_num, nb_sectors,
1084 &pnum1);
1085 if (allocated1 < 0) {
1086 ret = 3;
1087 error_report("Sector allocation test failed for %s", filename1);
1088 goto out;
1091 allocated2 = bdrv_is_allocated_above(bs2, NULL, sector_num, nb_sectors,
1092 &pnum2);
1093 if (allocated2 < 0) {
1094 ret = 3;
1095 error_report("Sector allocation test failed for %s", filename2);
1096 goto out;
1098 nb_sectors = MIN(pnum1, pnum2);
1100 if (allocated1 == allocated2) {
1101 if (allocated1) {
1102 ret = blk_read(blk1, sector_num, buf1, nb_sectors);
1103 if (ret < 0) {
1104 error_report("Error while reading offset %" PRId64 " of %s:"
1105 " %s", sectors_to_bytes(sector_num), filename1,
1106 strerror(-ret));
1107 ret = 4;
1108 goto out;
1110 ret = blk_read(blk2, sector_num, buf2, nb_sectors);
1111 if (ret < 0) {
1112 error_report("Error while reading offset %" PRId64
1113 " of %s: %s", sectors_to_bytes(sector_num),
1114 filename2, strerror(-ret));
1115 ret = 4;
1116 goto out;
1118 ret = compare_sectors(buf1, buf2, nb_sectors, &pnum);
1119 if (ret || pnum != nb_sectors) {
1120 qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
1121 sectors_to_bytes(
1122 ret ? sector_num : sector_num + pnum));
1123 ret = 1;
1124 goto out;
1127 } else {
1128 if (strict) {
1129 ret = 1;
1130 qprintf(quiet, "Strict mode: Offset %" PRId64
1131 " allocation mismatch!\n",
1132 sectors_to_bytes(sector_num));
1133 goto out;
1136 if (allocated1) {
1137 ret = check_empty_sectors(blk1, sector_num, nb_sectors,
1138 filename1, buf1, quiet);
1139 } else {
1140 ret = check_empty_sectors(blk2, sector_num, nb_sectors,
1141 filename2, buf1, quiet);
1143 if (ret) {
1144 if (ret < 0) {
1145 error_report("Error while reading offset %" PRId64 ": %s",
1146 sectors_to_bytes(sector_num), strerror(-ret));
1147 ret = 4;
1149 goto out;
1152 sector_num += nb_sectors;
1153 qemu_progress_print(((float) nb_sectors / progress_base)*100, 100);
1156 if (total_sectors1 != total_sectors2) {
1157 BlockBackend *blk_over;
1158 int64_t total_sectors_over;
1159 const char *filename_over;
1161 qprintf(quiet, "Warning: Image size mismatch!\n");
1162 if (total_sectors1 > total_sectors2) {
1163 total_sectors_over = total_sectors1;
1164 blk_over = blk1;
1165 filename_over = filename1;
1166 } else {
1167 total_sectors_over = total_sectors2;
1168 blk_over = blk2;
1169 filename_over = filename2;
1172 for (;;) {
1173 nb_sectors = sectors_to_process(total_sectors_over, sector_num);
1174 if (nb_sectors <= 0) {
1175 break;
1177 ret = bdrv_is_allocated_above(blk_bs(blk_over), NULL, sector_num,
1178 nb_sectors, &pnum);
1179 if (ret < 0) {
1180 ret = 3;
1181 error_report("Sector allocation test failed for %s",
1182 filename_over);
1183 goto out;
1186 nb_sectors = pnum;
1187 if (ret) {
1188 ret = check_empty_sectors(blk_over, sector_num, nb_sectors,
1189 filename_over, buf1, quiet);
1190 if (ret) {
1191 if (ret < 0) {
1192 error_report("Error while reading offset %" PRId64
1193 " of %s: %s", sectors_to_bytes(sector_num),
1194 filename_over, strerror(-ret));
1195 ret = 4;
1197 goto out;
1200 sector_num += nb_sectors;
1201 qemu_progress_print(((float) nb_sectors / progress_base)*100, 100);
1205 qprintf(quiet, "Images are identical.\n");
1206 ret = 0;
1208 out:
1209 qemu_vfree(buf1);
1210 qemu_vfree(buf2);
1211 blk_unref(blk2);
1212 out2:
1213 blk_unref(blk1);
1214 out3:
1215 qemu_progress_end();
1216 return ret;
1219 enum ImgConvertBlockStatus {
1220 BLK_DATA,
1221 BLK_ZERO,
1222 BLK_BACKING_FILE,
1225 typedef struct ImgConvertState {
1226 BlockBackend **src;
1227 int64_t *src_sectors;
1228 int src_cur, src_num;
1229 int64_t src_cur_offset;
1230 int64_t total_sectors;
1231 int64_t allocated_sectors;
1232 enum ImgConvertBlockStatus status;
1233 int64_t sector_next_status;
1234 BlockBackend *target;
1235 bool has_zero_init;
1236 bool compressed;
1237 bool target_has_backing;
1238 int min_sparse;
1239 size_t cluster_sectors;
1240 size_t buf_sectors;
1241 } ImgConvertState;
1243 static void convert_select_part(ImgConvertState *s, int64_t sector_num)
1245 assert(sector_num >= s->src_cur_offset);
1246 while (sector_num - s->src_cur_offset >= s->src_sectors[s->src_cur]) {
1247 s->src_cur_offset += s->src_sectors[s->src_cur];
1248 s->src_cur++;
1249 assert(s->src_cur < s->src_num);
1253 static int convert_iteration_sectors(ImgConvertState *s, int64_t sector_num)
1255 int64_t ret;
1256 int n;
1258 convert_select_part(s, sector_num);
1260 assert(s->total_sectors > sector_num);
1261 n = MIN(s->total_sectors - sector_num, BDRV_REQUEST_MAX_SECTORS);
1263 if (s->sector_next_status <= sector_num) {
1264 ret = bdrv_get_block_status(blk_bs(s->src[s->src_cur]),
1265 sector_num - s->src_cur_offset,
1266 n, &n);
1267 if (ret < 0) {
1268 return ret;
1271 if (ret & BDRV_BLOCK_ZERO) {
1272 s->status = BLK_ZERO;
1273 } else if (ret & BDRV_BLOCK_DATA) {
1274 s->status = BLK_DATA;
1275 } else if (!s->target_has_backing) {
1276 /* Without a target backing file we must copy over the contents of
1277 * the backing file as well. */
1278 /* TODO Check block status of the backing file chain to avoid
1279 * needlessly reading zeroes and limiting the iteration to the
1280 * buffer size */
1281 s->status = BLK_DATA;
1282 } else {
1283 s->status = BLK_BACKING_FILE;
1286 s->sector_next_status = sector_num + n;
1289 n = MIN(n, s->sector_next_status - sector_num);
1290 if (s->status == BLK_DATA) {
1291 n = MIN(n, s->buf_sectors);
1294 /* We need to write complete clusters for compressed images, so if an
1295 * unallocated area is shorter than that, we must consider the whole
1296 * cluster allocated. */
1297 if (s->compressed) {
1298 if (n < s->cluster_sectors) {
1299 n = MIN(s->cluster_sectors, s->total_sectors - sector_num);
1300 s->status = BLK_DATA;
1301 } else {
1302 n = QEMU_ALIGN_DOWN(n, s->cluster_sectors);
1306 return n;
1309 static int convert_read(ImgConvertState *s, int64_t sector_num, int nb_sectors,
1310 uint8_t *buf)
1312 int n;
1313 int ret;
1315 if (s->status == BLK_ZERO || s->status == BLK_BACKING_FILE) {
1316 return 0;
1319 assert(nb_sectors <= s->buf_sectors);
1320 while (nb_sectors > 0) {
1321 BlockBackend *blk;
1322 int64_t bs_sectors;
1324 /* In the case of compression with multiple source files, we can get a
1325 * nb_sectors that spreads into the next part. So we must be able to
1326 * read across multiple BDSes for one convert_read() call. */
1327 convert_select_part(s, sector_num);
1328 blk = s->src[s->src_cur];
1329 bs_sectors = s->src_sectors[s->src_cur];
1331 n = MIN(nb_sectors, bs_sectors - (sector_num - s->src_cur_offset));
1332 ret = blk_read(blk, sector_num - s->src_cur_offset, buf, n);
1333 if (ret < 0) {
1334 return ret;
1337 sector_num += n;
1338 nb_sectors -= n;
1339 buf += n * BDRV_SECTOR_SIZE;
1342 return 0;
1345 static int convert_write(ImgConvertState *s, int64_t sector_num, int nb_sectors,
1346 const uint8_t *buf)
1348 int ret;
1350 while (nb_sectors > 0) {
1351 int n = nb_sectors;
1353 switch (s->status) {
1354 case BLK_BACKING_FILE:
1355 /* If we have a backing file, leave clusters unallocated that are
1356 * unallocated in the source image, so that the backing file is
1357 * visible at the respective offset. */
1358 assert(s->target_has_backing);
1359 break;
1361 case BLK_DATA:
1362 /* We must always write compressed clusters as a whole, so don't
1363 * try to find zeroed parts in the buffer. We can only save the
1364 * write if the buffer is completely zeroed and we're allowed to
1365 * keep the target sparse. */
1366 if (s->compressed) {
1367 if (s->has_zero_init && s->min_sparse &&
1368 buffer_is_zero(buf, n * BDRV_SECTOR_SIZE))
1370 assert(!s->target_has_backing);
1371 break;
1374 ret = blk_write_compressed(s->target, sector_num, buf, n);
1375 if (ret < 0) {
1376 return ret;
1378 break;
1381 /* If there is real non-zero data or we're told to keep the target
1382 * fully allocated (-S 0), we must write it. Otherwise we can treat
1383 * it as zero sectors. */
1384 if (!s->min_sparse ||
1385 is_allocated_sectors_min(buf, n, &n, s->min_sparse))
1387 ret = blk_write(s->target, sector_num, buf, n);
1388 if (ret < 0) {
1389 return ret;
1391 break;
1393 /* fall-through */
1395 case BLK_ZERO:
1396 if (s->has_zero_init) {
1397 break;
1399 ret = blk_write_zeroes(s->target, sector_num, n, 0);
1400 if (ret < 0) {
1401 return ret;
1403 break;
1406 sector_num += n;
1407 nb_sectors -= n;
1408 buf += n * BDRV_SECTOR_SIZE;
1411 return 0;
1414 static int convert_do_copy(ImgConvertState *s)
1416 uint8_t *buf = NULL;
1417 int64_t sector_num, allocated_done;
1418 int ret;
1419 int n;
1421 /* Check whether we have zero initialisation or can get it efficiently */
1422 s->has_zero_init = s->min_sparse && !s->target_has_backing
1423 ? bdrv_has_zero_init(blk_bs(s->target))
1424 : false;
1426 if (!s->has_zero_init && !s->target_has_backing &&
1427 bdrv_can_write_zeroes_with_unmap(blk_bs(s->target)))
1429 ret = bdrv_make_zero(blk_bs(s->target), BDRV_REQ_MAY_UNMAP);
1430 if (ret == 0) {
1431 s->has_zero_init = true;
1435 /* Allocate buffer for copied data. For compressed images, only one cluster
1436 * can be copied at a time. */
1437 if (s->compressed) {
1438 if (s->cluster_sectors <= 0 || s->cluster_sectors > s->buf_sectors) {
1439 error_report("invalid cluster size");
1440 ret = -EINVAL;
1441 goto fail;
1443 s->buf_sectors = s->cluster_sectors;
1445 buf = blk_blockalign(s->target, s->buf_sectors * BDRV_SECTOR_SIZE);
1447 /* Calculate allocated sectors for progress */
1448 s->allocated_sectors = 0;
1449 sector_num = 0;
1450 while (sector_num < s->total_sectors) {
1451 n = convert_iteration_sectors(s, sector_num);
1452 if (n < 0) {
1453 ret = n;
1454 goto fail;
1456 if (s->status == BLK_DATA) {
1457 s->allocated_sectors += n;
1459 sector_num += n;
1462 /* Do the copy */
1463 s->src_cur = 0;
1464 s->src_cur_offset = 0;
1465 s->sector_next_status = 0;
1467 sector_num = 0;
1468 allocated_done = 0;
1470 while (sector_num < s->total_sectors) {
1471 n = convert_iteration_sectors(s, sector_num);
1472 if (n < 0) {
1473 ret = n;
1474 goto fail;
1476 if (s->status == BLK_DATA) {
1477 allocated_done += n;
1478 qemu_progress_print(100.0 * allocated_done / s->allocated_sectors,
1482 ret = convert_read(s, sector_num, n, buf);
1483 if (ret < 0) {
1484 error_report("error while reading sector %" PRId64
1485 ": %s", sector_num, strerror(-ret));
1486 goto fail;
1489 ret = convert_write(s, sector_num, n, buf);
1490 if (ret < 0) {
1491 error_report("error while writing sector %" PRId64
1492 ": %s", sector_num, strerror(-ret));
1493 goto fail;
1496 sector_num += n;
1499 if (s->compressed) {
1500 /* signal EOF to align */
1501 ret = blk_write_compressed(s->target, 0, NULL, 0);
1502 if (ret < 0) {
1503 goto fail;
1507 ret = 0;
1508 fail:
1509 qemu_vfree(buf);
1510 return ret;
1513 static int img_convert(int argc, char **argv)
1515 int c, bs_n, bs_i, compress, cluster_sectors, skip_create;
1516 int64_t ret = 0;
1517 int progress = 0, flags, src_flags;
1518 const char *fmt, *out_fmt, *cache, *src_cache, *out_baseimg, *out_filename;
1519 BlockDriver *drv, *proto_drv;
1520 BlockBackend **blk = NULL, *out_blk = NULL;
1521 BlockDriverState **bs = NULL, *out_bs = NULL;
1522 int64_t total_sectors;
1523 int64_t *bs_sectors = NULL;
1524 size_t bufsectors = IO_BUF_SIZE / BDRV_SECTOR_SIZE;
1525 BlockDriverInfo bdi;
1526 QemuOpts *opts = NULL;
1527 QemuOptsList *create_opts = NULL;
1528 const char *out_baseimg_param;
1529 char *options = NULL;
1530 const char *snapshot_name = NULL;
1531 int min_sparse = 8; /* Need at least 4k of zeros for sparse detection */
1532 bool quiet = false;
1533 Error *local_err = NULL;
1534 QemuOpts *sn_opts = NULL;
1535 ImgConvertState state;
1537 fmt = NULL;
1538 out_fmt = "raw";
1539 cache = "unsafe";
1540 src_cache = BDRV_DEFAULT_CACHE;
1541 out_baseimg = NULL;
1542 compress = 0;
1543 skip_create = 0;
1544 for(;;) {
1545 c = getopt(argc, argv, "hf:O:B:ce6o:s:l:S:pt:T:qn");
1546 if (c == -1) {
1547 break;
1549 switch(c) {
1550 case '?':
1551 case 'h':
1552 help();
1553 break;
1554 case 'f':
1555 fmt = optarg;
1556 break;
1557 case 'O':
1558 out_fmt = optarg;
1559 break;
1560 case 'B':
1561 out_baseimg = optarg;
1562 break;
1563 case 'c':
1564 compress = 1;
1565 break;
1566 case 'e':
1567 error_report("option -e is deprecated, please use \'-o "
1568 "encryption\' instead!");
1569 ret = -1;
1570 goto fail_getopt;
1571 case '6':
1572 error_report("option -6 is deprecated, please use \'-o "
1573 "compat6\' instead!");
1574 ret = -1;
1575 goto fail_getopt;
1576 case 'o':
1577 if (!is_valid_option_list(optarg)) {
1578 error_report("Invalid option list: %s", optarg);
1579 ret = -1;
1580 goto fail_getopt;
1582 if (!options) {
1583 options = g_strdup(optarg);
1584 } else {
1585 char *old_options = options;
1586 options = g_strdup_printf("%s,%s", options, optarg);
1587 g_free(old_options);
1589 break;
1590 case 's':
1591 snapshot_name = optarg;
1592 break;
1593 case 'l':
1594 if (strstart(optarg, SNAPSHOT_OPT_BASE, NULL)) {
1595 sn_opts = qemu_opts_parse_noisily(&internal_snapshot_opts,
1596 optarg, false);
1597 if (!sn_opts) {
1598 error_report("Failed in parsing snapshot param '%s'",
1599 optarg);
1600 ret = -1;
1601 goto fail_getopt;
1603 } else {
1604 snapshot_name = optarg;
1606 break;
1607 case 'S':
1609 int64_t sval;
1610 char *end;
1611 sval = qemu_strtosz_suffix(optarg, &end, QEMU_STRTOSZ_DEFSUFFIX_B);
1612 if (sval < 0 || *end) {
1613 error_report("Invalid minimum zero buffer size for sparse output specified");
1614 ret = -1;
1615 goto fail_getopt;
1618 min_sparse = sval / BDRV_SECTOR_SIZE;
1619 break;
1621 case 'p':
1622 progress = 1;
1623 break;
1624 case 't':
1625 cache = optarg;
1626 break;
1627 case 'T':
1628 src_cache = optarg;
1629 break;
1630 case 'q':
1631 quiet = true;
1632 break;
1633 case 'n':
1634 skip_create = 1;
1635 break;
1639 /* Initialize before goto out */
1640 if (quiet) {
1641 progress = 0;
1643 qemu_progress_init(progress, 1.0);
1646 bs_n = argc - optind - 1;
1647 out_filename = bs_n >= 1 ? argv[argc - 1] : NULL;
1649 if (options && has_help_option(options)) {
1650 ret = print_block_option_help(out_filename, out_fmt);
1651 goto out;
1654 if (bs_n < 1) {
1655 error_exit("Must specify image file name");
1659 if (bs_n > 1 && out_baseimg) {
1660 error_report("-B makes no sense when concatenating multiple input "
1661 "images");
1662 ret = -1;
1663 goto out;
1666 src_flags = BDRV_O_FLAGS;
1667 ret = bdrv_parse_cache_flags(src_cache, &src_flags);
1668 if (ret < 0) {
1669 error_report("Invalid source cache option: %s", src_cache);
1670 goto out;
1673 qemu_progress_print(0, 100);
1675 blk = g_new0(BlockBackend *, bs_n);
1676 bs = g_new0(BlockDriverState *, bs_n);
1677 bs_sectors = g_new(int64_t, bs_n);
1679 total_sectors = 0;
1680 for (bs_i = 0; bs_i < bs_n; bs_i++) {
1681 char *id = bs_n > 1 ? g_strdup_printf("source_%d", bs_i)
1682 : g_strdup("source");
1683 blk[bs_i] = img_open(id, argv[optind + bs_i], fmt, src_flags,
1684 true, quiet);
1685 g_free(id);
1686 if (!blk[bs_i]) {
1687 ret = -1;
1688 goto out;
1690 bs[bs_i] = blk_bs(blk[bs_i]);
1691 bs_sectors[bs_i] = blk_nb_sectors(blk[bs_i]);
1692 if (bs_sectors[bs_i] < 0) {
1693 error_report("Could not get size of %s: %s",
1694 argv[optind + bs_i], strerror(-bs_sectors[bs_i]));
1695 ret = -1;
1696 goto out;
1698 total_sectors += bs_sectors[bs_i];
1701 if (sn_opts) {
1702 ret = bdrv_snapshot_load_tmp(bs[0],
1703 qemu_opt_get(sn_opts, SNAPSHOT_OPT_ID),
1704 qemu_opt_get(sn_opts, SNAPSHOT_OPT_NAME),
1705 &local_err);
1706 } else if (snapshot_name != NULL) {
1707 if (bs_n > 1) {
1708 error_report("No support for concatenating multiple snapshot");
1709 ret = -1;
1710 goto out;
1713 bdrv_snapshot_load_tmp_by_id_or_name(bs[0], snapshot_name, &local_err);
1715 if (local_err) {
1716 error_report("Failed to load snapshot: %s",
1717 error_get_pretty(local_err));
1718 error_free(local_err);
1719 ret = -1;
1720 goto out;
1723 /* Find driver and parse its options */
1724 drv = bdrv_find_format(out_fmt);
1725 if (!drv) {
1726 error_report("Unknown file format '%s'", out_fmt);
1727 ret = -1;
1728 goto out;
1731 proto_drv = bdrv_find_protocol(out_filename, true, &local_err);
1732 if (!proto_drv) {
1733 error_report_err(local_err);
1734 ret = -1;
1735 goto out;
1738 if (!skip_create) {
1739 if (!drv->create_opts) {
1740 error_report("Format driver '%s' does not support image creation",
1741 drv->format_name);
1742 ret = -1;
1743 goto out;
1746 if (!proto_drv->create_opts) {
1747 error_report("Protocol driver '%s' does not support image creation",
1748 proto_drv->format_name);
1749 ret = -1;
1750 goto out;
1753 create_opts = qemu_opts_append(create_opts, drv->create_opts);
1754 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
1756 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
1757 if (options) {
1758 qemu_opts_do_parse(opts, options, NULL, &local_err);
1759 if (local_err) {
1760 error_report_err(local_err);
1761 ret = -1;
1762 goto out;
1766 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_sectors * 512,
1767 &error_abort);
1768 ret = add_old_style_options(out_fmt, opts, out_baseimg, NULL);
1769 if (ret < 0) {
1770 goto out;
1774 /* Get backing file name if -o backing_file was used */
1775 out_baseimg_param = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
1776 if (out_baseimg_param) {
1777 out_baseimg = out_baseimg_param;
1780 /* Check if compression is supported */
1781 if (compress) {
1782 bool encryption =
1783 qemu_opt_get_bool(opts, BLOCK_OPT_ENCRYPT, false);
1784 const char *preallocation =
1785 qemu_opt_get(opts, BLOCK_OPT_PREALLOC);
1787 if (!drv->bdrv_write_compressed) {
1788 error_report("Compression not supported for this file format");
1789 ret = -1;
1790 goto out;
1793 if (encryption) {
1794 error_report("Compression and encryption not supported at "
1795 "the same time");
1796 ret = -1;
1797 goto out;
1800 if (preallocation
1801 && strcmp(preallocation, "off"))
1803 error_report("Compression and preallocation not supported at "
1804 "the same time");
1805 ret = -1;
1806 goto out;
1810 if (!skip_create) {
1811 /* Create the new image */
1812 ret = bdrv_create(drv, out_filename, opts, &local_err);
1813 if (ret < 0) {
1814 error_report("%s: error while converting %s: %s",
1815 out_filename, out_fmt, error_get_pretty(local_err));
1816 error_free(local_err);
1817 goto out;
1821 flags = min_sparse ? (BDRV_O_RDWR | BDRV_O_UNMAP) : BDRV_O_RDWR;
1822 ret = bdrv_parse_cache_flags(cache, &flags);
1823 if (ret < 0) {
1824 error_report("Invalid cache option: %s", cache);
1825 goto out;
1828 out_blk = img_open("target", out_filename, out_fmt, flags, true, quiet);
1829 if (!out_blk) {
1830 ret = -1;
1831 goto out;
1833 out_bs = blk_bs(out_blk);
1835 /* increase bufsectors from the default 4096 (2M) if opt_transfer_length
1836 * or discard_alignment of the out_bs is greater. Limit to 32768 (16MB)
1837 * as maximum. */
1838 bufsectors = MIN(32768,
1839 MAX(bufsectors, MAX(out_bs->bl.opt_transfer_length,
1840 out_bs->bl.discard_alignment))
1843 if (skip_create) {
1844 int64_t output_sectors = blk_nb_sectors(out_blk);
1845 if (output_sectors < 0) {
1846 error_report("unable to get output image length: %s",
1847 strerror(-output_sectors));
1848 ret = -1;
1849 goto out;
1850 } else if (output_sectors < total_sectors) {
1851 error_report("output file is smaller than input file");
1852 ret = -1;
1853 goto out;
1857 cluster_sectors = 0;
1858 ret = bdrv_get_info(out_bs, &bdi);
1859 if (ret < 0) {
1860 if (compress) {
1861 error_report("could not get block driver info");
1862 goto out;
1864 } else {
1865 compress = compress || bdi.needs_compressed_writes;
1866 cluster_sectors = bdi.cluster_size / BDRV_SECTOR_SIZE;
1869 state = (ImgConvertState) {
1870 .src = blk,
1871 .src_sectors = bs_sectors,
1872 .src_num = bs_n,
1873 .total_sectors = total_sectors,
1874 .target = out_blk,
1875 .compressed = compress,
1876 .target_has_backing = (bool) out_baseimg,
1877 .min_sparse = min_sparse,
1878 .cluster_sectors = cluster_sectors,
1879 .buf_sectors = bufsectors,
1881 ret = convert_do_copy(&state);
1883 out:
1884 if (!ret) {
1885 qemu_progress_print(100, 0);
1887 qemu_progress_end();
1888 qemu_opts_del(opts);
1889 qemu_opts_free(create_opts);
1890 qemu_opts_del(sn_opts);
1891 blk_unref(out_blk);
1892 g_free(bs);
1893 if (blk) {
1894 for (bs_i = 0; bs_i < bs_n; bs_i++) {
1895 blk_unref(blk[bs_i]);
1897 g_free(blk);
1899 g_free(bs_sectors);
1900 fail_getopt:
1901 g_free(options);
1903 if (ret) {
1904 return 1;
1906 return 0;
1910 static void dump_snapshots(BlockDriverState *bs)
1912 QEMUSnapshotInfo *sn_tab, *sn;
1913 int nb_sns, i;
1915 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1916 if (nb_sns <= 0)
1917 return;
1918 printf("Snapshot list:\n");
1919 bdrv_snapshot_dump(fprintf, stdout, NULL);
1920 printf("\n");
1921 for(i = 0; i < nb_sns; i++) {
1922 sn = &sn_tab[i];
1923 bdrv_snapshot_dump(fprintf, stdout, sn);
1924 printf("\n");
1926 g_free(sn_tab);
1929 static void dump_json_image_info_list(ImageInfoList *list)
1931 Error *local_err = NULL;
1932 QString *str;
1933 QmpOutputVisitor *ov = qmp_output_visitor_new();
1934 QObject *obj;
1935 visit_type_ImageInfoList(qmp_output_get_visitor(ov),
1936 &list, NULL, &local_err);
1937 obj = qmp_output_get_qobject(ov);
1938 str = qobject_to_json_pretty(obj);
1939 assert(str != NULL);
1940 printf("%s\n", qstring_get_str(str));
1941 qobject_decref(obj);
1942 qmp_output_visitor_cleanup(ov);
1943 QDECREF(str);
1946 static void dump_json_image_info(ImageInfo *info)
1948 Error *local_err = NULL;
1949 QString *str;
1950 QmpOutputVisitor *ov = qmp_output_visitor_new();
1951 QObject *obj;
1952 visit_type_ImageInfo(qmp_output_get_visitor(ov),
1953 &info, NULL, &local_err);
1954 obj = qmp_output_get_qobject(ov);
1955 str = qobject_to_json_pretty(obj);
1956 assert(str != NULL);
1957 printf("%s\n", qstring_get_str(str));
1958 qobject_decref(obj);
1959 qmp_output_visitor_cleanup(ov);
1960 QDECREF(str);
1963 static void dump_human_image_info_list(ImageInfoList *list)
1965 ImageInfoList *elem;
1966 bool delim = false;
1968 for (elem = list; elem; elem = elem->next) {
1969 if (delim) {
1970 printf("\n");
1972 delim = true;
1974 bdrv_image_info_dump(fprintf, stdout, elem->value);
1978 static gboolean str_equal_func(gconstpointer a, gconstpointer b)
1980 return strcmp(a, b) == 0;
1984 * Open an image file chain and return an ImageInfoList
1986 * @filename: topmost image filename
1987 * @fmt: topmost image format (may be NULL to autodetect)
1988 * @chain: true - enumerate entire backing file chain
1989 * false - only topmost image file
1991 * Returns a list of ImageInfo objects or NULL if there was an error opening an
1992 * image file. If there was an error a message will have been printed to
1993 * stderr.
1995 static ImageInfoList *collect_image_info_list(const char *filename,
1996 const char *fmt,
1997 bool chain)
1999 ImageInfoList *head = NULL;
2000 ImageInfoList **last = &head;
2001 GHashTable *filenames;
2002 Error *err = NULL;
2004 filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL);
2006 while (filename) {
2007 BlockBackend *blk;
2008 BlockDriverState *bs;
2009 ImageInfo *info;
2010 ImageInfoList *elem;
2012 if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) {
2013 error_report("Backing file '%s' creates an infinite loop.",
2014 filename);
2015 goto err;
2017 g_hash_table_insert(filenames, (gpointer)filename, NULL);
2019 blk = img_open("image", filename, fmt,
2020 BDRV_O_FLAGS | BDRV_O_NO_BACKING, false, false);
2021 if (!blk) {
2022 goto err;
2024 bs = blk_bs(blk);
2026 bdrv_query_image_info(bs, &info, &err);
2027 if (err) {
2028 error_report_err(err);
2029 blk_unref(blk);
2030 goto err;
2033 elem = g_new0(ImageInfoList, 1);
2034 elem->value = info;
2035 *last = elem;
2036 last = &elem->next;
2038 blk_unref(blk);
2040 filename = fmt = NULL;
2041 if (chain) {
2042 if (info->has_full_backing_filename) {
2043 filename = info->full_backing_filename;
2044 } else if (info->has_backing_filename) {
2045 filename = info->backing_filename;
2047 if (info->has_backing_filename_format) {
2048 fmt = info->backing_filename_format;
2052 g_hash_table_destroy(filenames);
2053 return head;
2055 err:
2056 qapi_free_ImageInfoList(head);
2057 g_hash_table_destroy(filenames);
2058 return NULL;
2061 static int img_info(int argc, char **argv)
2063 int c;
2064 OutputFormat output_format = OFORMAT_HUMAN;
2065 bool chain = false;
2066 const char *filename, *fmt, *output;
2067 ImageInfoList *list;
2069 fmt = NULL;
2070 output = NULL;
2071 for(;;) {
2072 int option_index = 0;
2073 static const struct option long_options[] = {
2074 {"help", no_argument, 0, 'h'},
2075 {"format", required_argument, 0, 'f'},
2076 {"output", required_argument, 0, OPTION_OUTPUT},
2077 {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN},
2078 {0, 0, 0, 0}
2080 c = getopt_long(argc, argv, "f:h",
2081 long_options, &option_index);
2082 if (c == -1) {
2083 break;
2085 switch(c) {
2086 case '?':
2087 case 'h':
2088 help();
2089 break;
2090 case 'f':
2091 fmt = optarg;
2092 break;
2093 case OPTION_OUTPUT:
2094 output = optarg;
2095 break;
2096 case OPTION_BACKING_CHAIN:
2097 chain = true;
2098 break;
2101 if (optind != argc - 1) {
2102 error_exit("Expecting one image file name");
2104 filename = argv[optind++];
2106 if (output && !strcmp(output, "json")) {
2107 output_format = OFORMAT_JSON;
2108 } else if (output && !strcmp(output, "human")) {
2109 output_format = OFORMAT_HUMAN;
2110 } else if (output) {
2111 error_report("--output must be used with human or json as argument.");
2112 return 1;
2115 list = collect_image_info_list(filename, fmt, chain);
2116 if (!list) {
2117 return 1;
2120 switch (output_format) {
2121 case OFORMAT_HUMAN:
2122 dump_human_image_info_list(list);
2123 break;
2124 case OFORMAT_JSON:
2125 if (chain) {
2126 dump_json_image_info_list(list);
2127 } else {
2128 dump_json_image_info(list->value);
2130 break;
2133 qapi_free_ImageInfoList(list);
2134 return 0;
2138 typedef struct MapEntry {
2139 int flags;
2140 int depth;
2141 int64_t start;
2142 int64_t length;
2143 int64_t offset;
2144 BlockDriverState *bs;
2145 } MapEntry;
2147 static void dump_map_entry(OutputFormat output_format, MapEntry *e,
2148 MapEntry *next)
2150 switch (output_format) {
2151 case OFORMAT_HUMAN:
2152 if ((e->flags & BDRV_BLOCK_DATA) &&
2153 !(e->flags & BDRV_BLOCK_OFFSET_VALID)) {
2154 error_report("File contains external, encrypted or compressed clusters.");
2155 exit(1);
2157 if ((e->flags & (BDRV_BLOCK_DATA|BDRV_BLOCK_ZERO)) == BDRV_BLOCK_DATA) {
2158 printf("%#-16"PRIx64"%#-16"PRIx64"%#-16"PRIx64"%s\n",
2159 e->start, e->length, e->offset, e->bs->filename);
2161 /* This format ignores the distinction between 0, ZERO and ZERO|DATA.
2162 * Modify the flags here to allow more coalescing.
2164 if (next &&
2165 (next->flags & (BDRV_BLOCK_DATA|BDRV_BLOCK_ZERO)) != BDRV_BLOCK_DATA) {
2166 next->flags &= ~BDRV_BLOCK_DATA;
2167 next->flags |= BDRV_BLOCK_ZERO;
2169 break;
2170 case OFORMAT_JSON:
2171 printf("%s{ \"start\": %"PRId64", \"length\": %"PRId64", \"depth\": %d,"
2172 " \"zero\": %s, \"data\": %s",
2173 (e->start == 0 ? "[" : ",\n"),
2174 e->start, e->length, e->depth,
2175 (e->flags & BDRV_BLOCK_ZERO) ? "true" : "false",
2176 (e->flags & BDRV_BLOCK_DATA) ? "true" : "false");
2177 if (e->flags & BDRV_BLOCK_OFFSET_VALID) {
2178 printf(", \"offset\": %"PRId64"", e->offset);
2180 putchar('}');
2182 if (!next) {
2183 printf("]\n");
2185 break;
2189 static int get_block_status(BlockDriverState *bs, int64_t sector_num,
2190 int nb_sectors, MapEntry *e)
2192 int64_t ret;
2193 int depth;
2195 /* As an optimization, we could cache the current range of unallocated
2196 * clusters in each file of the chain, and avoid querying the same
2197 * range repeatedly.
2200 depth = 0;
2201 for (;;) {
2202 ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &nb_sectors);
2203 if (ret < 0) {
2204 return ret;
2206 assert(nb_sectors);
2207 if (ret & (BDRV_BLOCK_ZERO|BDRV_BLOCK_DATA)) {
2208 break;
2210 bs = backing_bs(bs);
2211 if (bs == NULL) {
2212 ret = 0;
2213 break;
2216 depth++;
2219 e->start = sector_num * BDRV_SECTOR_SIZE;
2220 e->length = nb_sectors * BDRV_SECTOR_SIZE;
2221 e->flags = ret & ~BDRV_BLOCK_OFFSET_MASK;
2222 e->offset = ret & BDRV_BLOCK_OFFSET_MASK;
2223 e->depth = depth;
2224 e->bs = bs;
2225 return 0;
2228 static int img_map(int argc, char **argv)
2230 int c;
2231 OutputFormat output_format = OFORMAT_HUMAN;
2232 BlockBackend *blk;
2233 BlockDriverState *bs;
2234 const char *filename, *fmt, *output;
2235 int64_t length;
2236 MapEntry curr = { .length = 0 }, next;
2237 int ret = 0;
2239 fmt = NULL;
2240 output = NULL;
2241 for (;;) {
2242 int option_index = 0;
2243 static const struct option long_options[] = {
2244 {"help", no_argument, 0, 'h'},
2245 {"format", required_argument, 0, 'f'},
2246 {"output", required_argument, 0, OPTION_OUTPUT},
2247 {0, 0, 0, 0}
2249 c = getopt_long(argc, argv, "f:h",
2250 long_options, &option_index);
2251 if (c == -1) {
2252 break;
2254 switch (c) {
2255 case '?':
2256 case 'h':
2257 help();
2258 break;
2259 case 'f':
2260 fmt = optarg;
2261 break;
2262 case OPTION_OUTPUT:
2263 output = optarg;
2264 break;
2267 if (optind != argc - 1) {
2268 error_exit("Expecting one image file name");
2270 filename = argv[optind];
2272 if (output && !strcmp(output, "json")) {
2273 output_format = OFORMAT_JSON;
2274 } else if (output && !strcmp(output, "human")) {
2275 output_format = OFORMAT_HUMAN;
2276 } else if (output) {
2277 error_report("--output must be used with human or json as argument.");
2278 return 1;
2281 blk = img_open("image", filename, fmt, BDRV_O_FLAGS, true, false);
2282 if (!blk) {
2283 return 1;
2285 bs = blk_bs(blk);
2287 if (output_format == OFORMAT_HUMAN) {
2288 printf("%-16s%-16s%-16s%s\n", "Offset", "Length", "Mapped to", "File");
2291 length = blk_getlength(blk);
2292 while (curr.start + curr.length < length) {
2293 int64_t nsectors_left;
2294 int64_t sector_num;
2295 int n;
2297 sector_num = (curr.start + curr.length) >> BDRV_SECTOR_BITS;
2299 /* Probe up to 1 GiB at a time. */
2300 nsectors_left = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE) - sector_num;
2301 n = MIN(1 << (30 - BDRV_SECTOR_BITS), nsectors_left);
2302 ret = get_block_status(bs, sector_num, n, &next);
2304 if (ret < 0) {
2305 error_report("Could not read file metadata: %s", strerror(-ret));
2306 goto out;
2309 if (curr.length != 0 && curr.flags == next.flags &&
2310 curr.depth == next.depth &&
2311 ((curr.flags & BDRV_BLOCK_OFFSET_VALID) == 0 ||
2312 curr.offset + curr.length == next.offset)) {
2313 curr.length += next.length;
2314 continue;
2317 if (curr.length > 0) {
2318 dump_map_entry(output_format, &curr, &next);
2320 curr = next;
2323 dump_map_entry(output_format, &curr, NULL);
2325 out:
2326 blk_unref(blk);
2327 return ret < 0;
2330 #define SNAPSHOT_LIST 1
2331 #define SNAPSHOT_CREATE 2
2332 #define SNAPSHOT_APPLY 3
2333 #define SNAPSHOT_DELETE 4
2335 static int img_snapshot(int argc, char **argv)
2337 BlockBackend *blk;
2338 BlockDriverState *bs;
2339 QEMUSnapshotInfo sn;
2340 char *filename, *snapshot_name = NULL;
2341 int c, ret = 0, bdrv_oflags;
2342 int action = 0;
2343 qemu_timeval tv;
2344 bool quiet = false;
2345 Error *err = NULL;
2347 bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
2348 /* Parse commandline parameters */
2349 for(;;) {
2350 c = getopt(argc, argv, "la:c:d:hq");
2351 if (c == -1) {
2352 break;
2354 switch(c) {
2355 case '?':
2356 case 'h':
2357 help();
2358 return 0;
2359 case 'l':
2360 if (action) {
2361 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2362 return 0;
2364 action = SNAPSHOT_LIST;
2365 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
2366 break;
2367 case 'a':
2368 if (action) {
2369 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2370 return 0;
2372 action = SNAPSHOT_APPLY;
2373 snapshot_name = optarg;
2374 break;
2375 case 'c':
2376 if (action) {
2377 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2378 return 0;
2380 action = SNAPSHOT_CREATE;
2381 snapshot_name = optarg;
2382 break;
2383 case 'd':
2384 if (action) {
2385 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2386 return 0;
2388 action = SNAPSHOT_DELETE;
2389 snapshot_name = optarg;
2390 break;
2391 case 'q':
2392 quiet = true;
2393 break;
2397 if (optind != argc - 1) {
2398 error_exit("Expecting one image file name");
2400 filename = argv[optind++];
2402 /* Open the image */
2403 blk = img_open("image", filename, NULL, bdrv_oflags, true, quiet);
2404 if (!blk) {
2405 return 1;
2407 bs = blk_bs(blk);
2409 /* Perform the requested action */
2410 switch(action) {
2411 case SNAPSHOT_LIST:
2412 dump_snapshots(bs);
2413 break;
2415 case SNAPSHOT_CREATE:
2416 memset(&sn, 0, sizeof(sn));
2417 pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
2419 qemu_gettimeofday(&tv);
2420 sn.date_sec = tv.tv_sec;
2421 sn.date_nsec = tv.tv_usec * 1000;
2423 ret = bdrv_snapshot_create(bs, &sn);
2424 if (ret) {
2425 error_report("Could not create snapshot '%s': %d (%s)",
2426 snapshot_name, ret, strerror(-ret));
2428 break;
2430 case SNAPSHOT_APPLY:
2431 ret = bdrv_snapshot_goto(bs, snapshot_name);
2432 if (ret) {
2433 error_report("Could not apply snapshot '%s': %d (%s)",
2434 snapshot_name, ret, strerror(-ret));
2436 break;
2438 case SNAPSHOT_DELETE:
2439 bdrv_snapshot_delete_by_id_or_name(bs, snapshot_name, &err);
2440 if (err) {
2441 error_report("Could not delete snapshot '%s': (%s)",
2442 snapshot_name, error_get_pretty(err));
2443 error_free(err);
2444 ret = 1;
2446 break;
2449 /* Cleanup */
2450 blk_unref(blk);
2451 if (ret) {
2452 return 1;
2454 return 0;
2457 static int img_rebase(int argc, char **argv)
2459 BlockBackend *blk = NULL, *blk_old_backing = NULL, *blk_new_backing = NULL;
2460 BlockDriverState *bs = NULL;
2461 char *filename;
2462 const char *fmt, *cache, *src_cache, *out_basefmt, *out_baseimg;
2463 int c, flags, src_flags, ret;
2464 int unsafe = 0;
2465 int progress = 0;
2466 bool quiet = false;
2467 Error *local_err = NULL;
2469 /* Parse commandline parameters */
2470 fmt = NULL;
2471 cache = BDRV_DEFAULT_CACHE;
2472 src_cache = BDRV_DEFAULT_CACHE;
2473 out_baseimg = NULL;
2474 out_basefmt = NULL;
2475 for(;;) {
2476 c = getopt(argc, argv, "hf:F:b:upt:T:q");
2477 if (c == -1) {
2478 break;
2480 switch(c) {
2481 case '?':
2482 case 'h':
2483 help();
2484 return 0;
2485 case 'f':
2486 fmt = optarg;
2487 break;
2488 case 'F':
2489 out_basefmt = optarg;
2490 break;
2491 case 'b':
2492 out_baseimg = optarg;
2493 break;
2494 case 'u':
2495 unsafe = 1;
2496 break;
2497 case 'p':
2498 progress = 1;
2499 break;
2500 case 't':
2501 cache = optarg;
2502 break;
2503 case 'T':
2504 src_cache = optarg;
2505 break;
2506 case 'q':
2507 quiet = true;
2508 break;
2512 if (quiet) {
2513 progress = 0;
2516 if (optind != argc - 1) {
2517 error_exit("Expecting one image file name");
2519 if (!unsafe && !out_baseimg) {
2520 error_exit("Must specify backing file (-b) or use unsafe mode (-u)");
2522 filename = argv[optind++];
2524 qemu_progress_init(progress, 2.0);
2525 qemu_progress_print(0, 100);
2527 flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
2528 ret = bdrv_parse_cache_flags(cache, &flags);
2529 if (ret < 0) {
2530 error_report("Invalid cache option: %s", cache);
2531 goto out;
2534 src_flags = BDRV_O_FLAGS;
2535 ret = bdrv_parse_cache_flags(src_cache, &src_flags);
2536 if (ret < 0) {
2537 error_report("Invalid source cache option: %s", src_cache);
2538 goto out;
2542 * Open the images.
2544 * Ignore the old backing file for unsafe rebase in case we want to correct
2545 * the reference to a renamed or moved backing file.
2547 blk = img_open("image", filename, fmt, flags, true, quiet);
2548 if (!blk) {
2549 ret = -1;
2550 goto out;
2552 bs = blk_bs(blk);
2554 if (out_basefmt != NULL) {
2555 if (bdrv_find_format(out_basefmt) == NULL) {
2556 error_report("Invalid format name: '%s'", out_basefmt);
2557 ret = -1;
2558 goto out;
2562 /* For safe rebasing we need to compare old and new backing file */
2563 if (!unsafe) {
2564 char backing_name[PATH_MAX];
2565 QDict *options = NULL;
2567 if (bs->backing_format[0] != '\0') {
2568 options = qdict_new();
2569 qdict_put(options, "driver", qstring_from_str(bs->backing_format));
2572 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
2573 blk_old_backing = blk_new_open("old_backing", backing_name, NULL,
2574 options, src_flags, &local_err);
2575 if (!blk_old_backing) {
2576 error_report("Could not open old backing file '%s': %s",
2577 backing_name, error_get_pretty(local_err));
2578 error_free(local_err);
2579 goto out;
2582 if (out_baseimg[0]) {
2583 if (out_basefmt) {
2584 options = qdict_new();
2585 qdict_put(options, "driver", qstring_from_str(out_basefmt));
2586 } else {
2587 options = NULL;
2590 blk_new_backing = blk_new_open("new_backing", out_baseimg, NULL,
2591 options, src_flags, &local_err);
2592 if (!blk_new_backing) {
2593 error_report("Could not open new backing file '%s': %s",
2594 out_baseimg, error_get_pretty(local_err));
2595 error_free(local_err);
2596 goto out;
2602 * Check each unallocated cluster in the COW file. If it is unallocated,
2603 * accesses go to the backing file. We must therefore compare this cluster
2604 * in the old and new backing file, and if they differ we need to copy it
2605 * from the old backing file into the COW file.
2607 * If qemu-img crashes during this step, no harm is done. The content of
2608 * the image is the same as the original one at any time.
2610 if (!unsafe) {
2611 int64_t num_sectors;
2612 int64_t old_backing_num_sectors;
2613 int64_t new_backing_num_sectors = 0;
2614 uint64_t sector;
2615 int n;
2616 uint8_t * buf_old;
2617 uint8_t * buf_new;
2618 float local_progress = 0;
2620 buf_old = blk_blockalign(blk, IO_BUF_SIZE);
2621 buf_new = blk_blockalign(blk, IO_BUF_SIZE);
2623 num_sectors = blk_nb_sectors(blk);
2624 if (num_sectors < 0) {
2625 error_report("Could not get size of '%s': %s",
2626 filename, strerror(-num_sectors));
2627 ret = -1;
2628 goto out;
2630 old_backing_num_sectors = blk_nb_sectors(blk_old_backing);
2631 if (old_backing_num_sectors < 0) {
2632 char backing_name[PATH_MAX];
2634 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
2635 error_report("Could not get size of '%s': %s",
2636 backing_name, strerror(-old_backing_num_sectors));
2637 ret = -1;
2638 goto out;
2640 if (blk_new_backing) {
2641 new_backing_num_sectors = blk_nb_sectors(blk_new_backing);
2642 if (new_backing_num_sectors < 0) {
2643 error_report("Could not get size of '%s': %s",
2644 out_baseimg, strerror(-new_backing_num_sectors));
2645 ret = -1;
2646 goto out;
2650 if (num_sectors != 0) {
2651 local_progress = (float)100 /
2652 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
2655 for (sector = 0; sector < num_sectors; sector += n) {
2657 /* How many sectors can we handle with the next read? */
2658 if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
2659 n = (IO_BUF_SIZE / 512);
2660 } else {
2661 n = num_sectors - sector;
2664 /* If the cluster is allocated, we don't need to take action */
2665 ret = bdrv_is_allocated(bs, sector, n, &n);
2666 if (ret < 0) {
2667 error_report("error while reading image metadata: %s",
2668 strerror(-ret));
2669 goto out;
2671 if (ret) {
2672 continue;
2676 * Read old and new backing file and take into consideration that
2677 * backing files may be smaller than the COW image.
2679 if (sector >= old_backing_num_sectors) {
2680 memset(buf_old, 0, n * BDRV_SECTOR_SIZE);
2681 } else {
2682 if (sector + n > old_backing_num_sectors) {
2683 n = old_backing_num_sectors - sector;
2686 ret = blk_read(blk_old_backing, sector, buf_old, n);
2687 if (ret < 0) {
2688 error_report("error while reading from old backing file");
2689 goto out;
2693 if (sector >= new_backing_num_sectors || !blk_new_backing) {
2694 memset(buf_new, 0, n * BDRV_SECTOR_SIZE);
2695 } else {
2696 if (sector + n > new_backing_num_sectors) {
2697 n = new_backing_num_sectors - sector;
2700 ret = blk_read(blk_new_backing, sector, buf_new, n);
2701 if (ret < 0) {
2702 error_report("error while reading from new backing file");
2703 goto out;
2707 /* If they differ, we need to write to the COW file */
2708 uint64_t written = 0;
2710 while (written < n) {
2711 int pnum;
2713 if (compare_sectors(buf_old + written * 512,
2714 buf_new + written * 512, n - written, &pnum))
2716 ret = blk_write(blk, sector + written,
2717 buf_old + written * 512, pnum);
2718 if (ret < 0) {
2719 error_report("Error while writing to COW image: %s",
2720 strerror(-ret));
2721 goto out;
2725 written += pnum;
2727 qemu_progress_print(local_progress, 100);
2730 qemu_vfree(buf_old);
2731 qemu_vfree(buf_new);
2735 * Change the backing file. All clusters that are different from the old
2736 * backing file are overwritten in the COW file now, so the visible content
2737 * doesn't change when we switch the backing file.
2739 if (out_baseimg && *out_baseimg) {
2740 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
2741 } else {
2742 ret = bdrv_change_backing_file(bs, NULL, NULL);
2745 if (ret == -ENOSPC) {
2746 error_report("Could not change the backing file to '%s': No "
2747 "space left in the file header", out_baseimg);
2748 } else if (ret < 0) {
2749 error_report("Could not change the backing file to '%s': %s",
2750 out_baseimg, strerror(-ret));
2753 qemu_progress_print(100, 0);
2755 * TODO At this point it is possible to check if any clusters that are
2756 * allocated in the COW file are the same in the backing file. If so, they
2757 * could be dropped from the COW file. Don't do this before switching the
2758 * backing file, in case of a crash this would lead to corruption.
2760 out:
2761 qemu_progress_end();
2762 /* Cleanup */
2763 if (!unsafe) {
2764 blk_unref(blk_old_backing);
2765 blk_unref(blk_new_backing);
2768 blk_unref(blk);
2769 if (ret) {
2770 return 1;
2772 return 0;
2775 static int img_resize(int argc, char **argv)
2777 Error *err = NULL;
2778 int c, ret, relative;
2779 const char *filename, *fmt, *size;
2780 int64_t n, total_size;
2781 bool quiet = false;
2782 BlockBackend *blk = NULL;
2783 QemuOpts *param;
2784 static QemuOptsList resize_options = {
2785 .name = "resize_options",
2786 .head = QTAILQ_HEAD_INITIALIZER(resize_options.head),
2787 .desc = {
2789 .name = BLOCK_OPT_SIZE,
2790 .type = QEMU_OPT_SIZE,
2791 .help = "Virtual disk size"
2792 }, {
2793 /* end of list */
2798 /* Remove size from argv manually so that negative numbers are not treated
2799 * as options by getopt. */
2800 if (argc < 3) {
2801 error_exit("Not enough arguments");
2802 return 1;
2805 size = argv[--argc];
2807 /* Parse getopt arguments */
2808 fmt = NULL;
2809 for(;;) {
2810 c = getopt(argc, argv, "f:hq");
2811 if (c == -1) {
2812 break;
2814 switch(c) {
2815 case '?':
2816 case 'h':
2817 help();
2818 break;
2819 case 'f':
2820 fmt = optarg;
2821 break;
2822 case 'q':
2823 quiet = true;
2824 break;
2827 if (optind != argc - 1) {
2828 error_exit("Expecting one image file name");
2830 filename = argv[optind++];
2832 /* Choose grow, shrink, or absolute resize mode */
2833 switch (size[0]) {
2834 case '+':
2835 relative = 1;
2836 size++;
2837 break;
2838 case '-':
2839 relative = -1;
2840 size++;
2841 break;
2842 default:
2843 relative = 0;
2844 break;
2847 /* Parse size */
2848 param = qemu_opts_create(&resize_options, NULL, 0, &error_abort);
2849 qemu_opt_set(param, BLOCK_OPT_SIZE, size, &err);
2850 if (err) {
2851 error_report_err(err);
2852 ret = -1;
2853 qemu_opts_del(param);
2854 goto out;
2856 n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
2857 qemu_opts_del(param);
2859 blk = img_open("image", filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR,
2860 true, quiet);
2861 if (!blk) {
2862 ret = -1;
2863 goto out;
2866 if (relative) {
2867 total_size = blk_getlength(blk) + n * relative;
2868 } else {
2869 total_size = n;
2871 if (total_size <= 0) {
2872 error_report("New image size must be positive");
2873 ret = -1;
2874 goto out;
2877 ret = blk_truncate(blk, total_size);
2878 switch (ret) {
2879 case 0:
2880 qprintf(quiet, "Image resized.\n");
2881 break;
2882 case -ENOTSUP:
2883 error_report("This image does not support resize");
2884 break;
2885 case -EACCES:
2886 error_report("Image is read-only");
2887 break;
2888 default:
2889 error_report("Error resizing image (%d)", -ret);
2890 break;
2892 out:
2893 blk_unref(blk);
2894 if (ret) {
2895 return 1;
2897 return 0;
2900 static void amend_status_cb(BlockDriverState *bs,
2901 int64_t offset, int64_t total_work_size)
2903 qemu_progress_print(100.f * offset / total_work_size, 0);
2906 static int img_amend(int argc, char **argv)
2908 Error *err = NULL;
2909 int c, ret = 0;
2910 char *options = NULL;
2911 QemuOptsList *create_opts = NULL;
2912 QemuOpts *opts = NULL;
2913 const char *fmt = NULL, *filename, *cache;
2914 int flags;
2915 bool quiet = false, progress = false;
2916 BlockBackend *blk = NULL;
2917 BlockDriverState *bs = NULL;
2919 cache = BDRV_DEFAULT_CACHE;
2920 for (;;) {
2921 c = getopt(argc, argv, "ho:f:t:pq");
2922 if (c == -1) {
2923 break;
2926 switch (c) {
2927 case 'h':
2928 case '?':
2929 help();
2930 break;
2931 case 'o':
2932 if (!is_valid_option_list(optarg)) {
2933 error_report("Invalid option list: %s", optarg);
2934 ret = -1;
2935 goto out_no_progress;
2937 if (!options) {
2938 options = g_strdup(optarg);
2939 } else {
2940 char *old_options = options;
2941 options = g_strdup_printf("%s,%s", options, optarg);
2942 g_free(old_options);
2944 break;
2945 case 'f':
2946 fmt = optarg;
2947 break;
2948 case 't':
2949 cache = optarg;
2950 break;
2951 case 'p':
2952 progress = true;
2953 break;
2954 case 'q':
2955 quiet = true;
2956 break;
2960 if (!options) {
2961 error_exit("Must specify options (-o)");
2964 if (quiet) {
2965 progress = false;
2967 qemu_progress_init(progress, 1.0);
2969 filename = (optind == argc - 1) ? argv[argc - 1] : NULL;
2970 if (fmt && has_help_option(options)) {
2971 /* If a format is explicitly specified (and possibly no filename is
2972 * given), print option help here */
2973 ret = print_block_option_help(filename, fmt);
2974 goto out;
2977 if (optind != argc - 1) {
2978 error_report("Expecting one image file name");
2979 ret = -1;
2980 goto out;
2983 flags = BDRV_O_FLAGS | BDRV_O_RDWR;
2984 ret = bdrv_parse_cache_flags(cache, &flags);
2985 if (ret < 0) {
2986 error_report("Invalid cache option: %s", cache);
2987 goto out;
2990 blk = img_open("image", filename, fmt, flags, true, quiet);
2991 if (!blk) {
2992 ret = -1;
2993 goto out;
2995 bs = blk_bs(blk);
2997 fmt = bs->drv->format_name;
2999 if (has_help_option(options)) {
3000 /* If the format was auto-detected, print option help here */
3001 ret = print_block_option_help(filename, fmt);
3002 goto out;
3005 if (!bs->drv->create_opts) {
3006 error_report("Format driver '%s' does not support any options to amend",
3007 fmt);
3008 ret = -1;
3009 goto out;
3012 create_opts = qemu_opts_append(create_opts, bs->drv->create_opts);
3013 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
3014 if (options) {
3015 qemu_opts_do_parse(opts, options, NULL, &err);
3016 if (err) {
3017 error_report_err(err);
3018 ret = -1;
3019 goto out;
3023 /* In case the driver does not call amend_status_cb() */
3024 qemu_progress_print(0.f, 0);
3025 ret = bdrv_amend_options(bs, opts, &amend_status_cb);
3026 qemu_progress_print(100.f, 0);
3027 if (ret < 0) {
3028 error_report("Error while amending options: %s", strerror(-ret));
3029 goto out;
3032 out:
3033 qemu_progress_end();
3035 out_no_progress:
3036 blk_unref(blk);
3037 qemu_opts_del(opts);
3038 qemu_opts_free(create_opts);
3039 g_free(options);
3041 if (ret) {
3042 return 1;
3044 return 0;
3047 static const img_cmd_t img_cmds[] = {
3048 #define DEF(option, callback, arg_string) \
3049 { option, callback },
3050 #include "qemu-img-cmds.h"
3051 #undef DEF
3052 #undef GEN_DOCS
3053 { NULL, NULL, },
3056 int main(int argc, char **argv)
3058 const img_cmd_t *cmd;
3059 const char *cmdname;
3060 Error *local_error = NULL;
3061 int c;
3062 static const struct option long_options[] = {
3063 {"help", no_argument, 0, 'h'},
3064 {"version", no_argument, 0, 'v'},
3065 {0, 0, 0, 0}
3068 #ifdef CONFIG_POSIX
3069 signal(SIGPIPE, SIG_IGN);
3070 #endif
3072 error_set_progname(argv[0]);
3073 qemu_init_exec_dir(argv[0]);
3075 if (qemu_init_main_loop(&local_error)) {
3076 error_report_err(local_error);
3077 exit(EXIT_FAILURE);
3080 bdrv_init();
3081 if (argc < 2) {
3082 error_exit("Not enough arguments");
3084 cmdname = argv[1];
3086 /* find the command */
3087 for (cmd = img_cmds; cmd->name != NULL; cmd++) {
3088 if (!strcmp(cmdname, cmd->name)) {
3089 return cmd->handler(argc - 1, argv + 1);
3093 c = getopt_long(argc, argv, "h", long_options, NULL);
3095 if (c == 'h') {
3096 help();
3098 if (c == 'v') {
3099 printf(QEMU_IMG_VERSION);
3100 return 0;
3103 /* not found */
3104 error_exit("Command not found: %s", cmdname);