io: pass HANDLE to g_source_add_poll on Win32
[qemu/ar7.git] / qemu-img.c
blob2edb139073869df728954aa7ca4c0bf74d893cba
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 "qemu/osdep.h"
25 #include "qapi-visit.h"
26 #include "qapi/qmp-output-visitor.h"
27 #include "qapi/qmp/qerror.h"
28 #include "qapi/qmp/qjson.h"
29 #include "qemu-common.h"
30 #include "qemu/config-file.h"
31 #include "qemu/option.h"
32 #include "qemu/error-report.h"
33 #include "qom/object_interfaces.h"
34 #include "sysemu/sysemu.h"
35 #include "sysemu/block-backend.h"
36 #include "block/block_int.h"
37 #include "block/blockjob.h"
38 #include "block/qapi.h"
39 #include <getopt.h>
41 #define QEMU_IMG_VERSION "qemu-img version " QEMU_VERSION QEMU_PKGVERSION \
42 ", Copyright (c) 2004-2008 Fabrice Bellard\n"
44 typedef struct img_cmd_t {
45 const char *name;
46 int (*handler)(int argc, char **argv);
47 } img_cmd_t;
49 enum {
50 OPTION_OUTPUT = 256,
51 OPTION_BACKING_CHAIN = 257,
52 OPTION_OBJECT = 258,
53 OPTION_IMAGE_OPTS = 259,
56 typedef enum OutputFormat {
57 OFORMAT_JSON,
58 OFORMAT_HUMAN,
59 } OutputFormat;
61 /* Default to cache=writeback as data integrity is not important for qemu-tcg. */
62 #define BDRV_O_FLAGS BDRV_O_CACHE_WB
63 #define BDRV_DEFAULT_CACHE "writeback"
65 static void format_print(void *opaque, const char *name)
67 printf(" %s", name);
70 static void QEMU_NORETURN GCC_FMT_ATTR(1, 2) error_exit(const char *fmt, ...)
72 va_list ap;
74 error_printf("qemu-img: ");
76 va_start(ap, fmt);
77 error_vprintf(fmt, ap);
78 va_end(ap);
80 error_printf("\nTry 'qemu-img --help' for more information\n");
81 exit(EXIT_FAILURE);
84 /* Please keep in synch with qemu-img.texi */
85 static void QEMU_NORETURN help(void)
87 const char *help_msg =
88 QEMU_IMG_VERSION
89 "usage: qemu-img command [command options]\n"
90 "QEMU disk image utility\n"
91 "\n"
92 "Command syntax:\n"
93 #define DEF(option, callback, arg_string) \
94 " " arg_string "\n"
95 #include "qemu-img-cmds.h"
96 #undef DEF
97 #undef GEN_DOCS
98 "\n"
99 "Command parameters:\n"
100 " 'filename' is a disk image filename\n"
101 " 'objectdef' is a QEMU user creatable object definition. See the qemu(1)\n"
102 " manual page for a description of the object properties. The most common\n"
103 " object type is a 'secret', which is used to supply passwords and/or\n"
104 " encryption keys.\n"
105 " 'fmt' is the disk image format. It is guessed automatically in most cases\n"
106 " 'cache' is the cache mode used to write the output disk image, the valid\n"
107 " options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n"
108 " 'directsync' and 'unsafe' (default for convert)\n"
109 " 'src_cache' is the cache mode used to read input disk images, the valid\n"
110 " options are the same as for the 'cache' option\n"
111 " 'size' is the disk image size in bytes. Optional suffixes\n"
112 " 'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M),\n"
113 " 'T' (terabyte, 1024G), 'P' (petabyte, 1024T) and 'E' (exabyte, 1024P) are\n"
114 " supported. 'b' is ignored.\n"
115 " 'output_filename' is the destination disk image filename\n"
116 " 'output_fmt' is the destination format\n"
117 " 'options' is a comma separated list of format specific options in a\n"
118 " name=value format. Use -o ? for an overview of the options supported by the\n"
119 " used format\n"
120 " 'snapshot_param' is param used for internal snapshot, format\n"
121 " is 'snapshot.id=[ID],snapshot.name=[NAME]', or\n"
122 " '[ID_OR_NAME]'\n"
123 " 'snapshot_id_or_name' is deprecated, use 'snapshot_param'\n"
124 " instead\n"
125 " '-c' indicates that target image must be compressed (qcow format only)\n"
126 " '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
127 " match exactly. The image doesn't need a working backing file before\n"
128 " rebasing in this case (useful for renaming the backing file)\n"
129 " '-h' with or without a command shows this help and lists the supported formats\n"
130 " '-p' show progress of command (only certain commands)\n"
131 " '-q' use Quiet mode - do not print any output (except errors)\n"
132 " '-S' indicates the consecutive number of bytes (defaults to 4k) that must\n"
133 " contain only zeros for qemu-img to create a sparse image during\n"
134 " conversion. If the number of bytes is 0, the source will not be scanned for\n"
135 " unallocated or zero sectors, and the destination image will always be\n"
136 " fully allocated\n"
137 " '--output' takes the format in which the output must be done (human or json)\n"
138 " '-n' skips the target volume creation (useful if the volume is created\n"
139 " prior to running qemu-img)\n"
140 "\n"
141 "Parameters to check subcommand:\n"
142 " '-r' tries to repair any inconsistencies that are found during the check.\n"
143 " '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n"
144 " kinds of errors, with a higher risk of choosing the wrong fix or\n"
145 " hiding corruption that has already occurred.\n"
146 "\n"
147 "Parameters to snapshot subcommand:\n"
148 " 'snapshot' is the name of the snapshot to create, apply or delete\n"
149 " '-a' applies a snapshot (revert disk to saved state)\n"
150 " '-c' creates a snapshot\n"
151 " '-d' deletes a snapshot\n"
152 " '-l' lists all snapshots in the given image\n"
153 "\n"
154 "Parameters to compare subcommand:\n"
155 " '-f' first image format\n"
156 " '-F' second image format\n"
157 " '-s' run in Strict mode - fail on different image size or sector allocation\n";
159 printf("%s\nSupported formats:", help_msg);
160 bdrv_iterate_format(format_print, NULL);
161 printf("\n");
162 exit(EXIT_SUCCESS);
165 static QemuOptsList qemu_object_opts = {
166 .name = "object",
167 .implied_opt_name = "qom-type",
168 .head = QTAILQ_HEAD_INITIALIZER(qemu_object_opts.head),
169 .desc = {
174 static QemuOptsList qemu_source_opts = {
175 .name = "source",
176 .implied_opt_name = "file",
177 .head = QTAILQ_HEAD_INITIALIZER(qemu_source_opts.head),
178 .desc = {
183 static int GCC_FMT_ATTR(2, 3) qprintf(bool quiet, const char *fmt, ...)
185 int ret = 0;
186 if (!quiet) {
187 va_list args;
188 va_start(args, fmt);
189 ret = vprintf(fmt, args);
190 va_end(args);
192 return ret;
196 static int print_block_option_help(const char *filename, const char *fmt)
198 BlockDriver *drv, *proto_drv;
199 QemuOptsList *create_opts = NULL;
200 Error *local_err = NULL;
202 /* Find driver and parse its options */
203 drv = bdrv_find_format(fmt);
204 if (!drv) {
205 error_report("Unknown file format '%s'", fmt);
206 return 1;
209 create_opts = qemu_opts_append(create_opts, drv->create_opts);
210 if (filename) {
211 proto_drv = bdrv_find_protocol(filename, true, &local_err);
212 if (!proto_drv) {
213 error_report_err(local_err);
214 qemu_opts_free(create_opts);
215 return 1;
217 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
220 qemu_opts_print_help(create_opts);
221 qemu_opts_free(create_opts);
222 return 0;
226 static int img_open_password(BlockBackend *blk, const char *filename,
227 bool require_io, bool quiet)
229 BlockDriverState *bs;
230 char password[256];
232 bs = blk_bs(blk);
233 if (bdrv_is_encrypted(bs) && require_io) {
234 qprintf(quiet, "Disk image '%s' is encrypted.\n", filename);
235 if (qemu_read_password(password, sizeof(password)) < 0) {
236 error_report("No password given");
237 return -1;
239 if (bdrv_set_key(bs, password) < 0) {
240 error_report("invalid password");
241 return -1;
244 return 0;
248 static BlockBackend *img_open_opts(const char *id,
249 const char *optstr,
250 QemuOpts *opts, int flags,
251 bool require_io, bool quiet)
253 QDict *options;
254 Error *local_err = NULL;
255 BlockBackend *blk;
256 options = qemu_opts_to_qdict(opts, NULL);
257 blk = blk_new_open(id, NULL, NULL, options, flags, &local_err);
258 if (!blk) {
259 error_reportf_err(local_err, "Could not open '%s'", optstr);
260 return NULL;
263 if (img_open_password(blk, optstr, require_io, quiet) < 0) {
264 blk_unref(blk);
265 return NULL;
267 return blk;
270 static BlockBackend *img_open_file(const char *id, const char *filename,
271 const char *fmt, int flags,
272 bool require_io, bool quiet)
274 BlockBackend *blk;
275 Error *local_err = NULL;
276 QDict *options = NULL;
278 if (fmt) {
279 options = qdict_new();
280 qdict_put(options, "driver", qstring_from_str(fmt));
283 blk = blk_new_open(id, filename, NULL, options, flags, &local_err);
284 if (!blk) {
285 error_reportf_err(local_err, "Could not open '%s': ", filename);
286 return NULL;
289 if (img_open_password(blk, filename, require_io, quiet) < 0) {
290 blk_unref(blk);
291 return NULL;
293 return blk;
297 static BlockBackend *img_open(const char *id,
298 bool image_opts,
299 const char *filename,
300 const char *fmt, int flags,
301 bool require_io, bool quiet)
303 BlockBackend *blk;
304 if (image_opts) {
305 QemuOpts *opts;
306 if (fmt) {
307 error_report("--image-opts and --format are mutually exclusive");
308 return NULL;
310 opts = qemu_opts_parse_noisily(qemu_find_opts("source"),
311 filename, true);
312 if (!opts) {
313 return NULL;
315 blk = img_open_opts(id, filename, opts, flags, true, quiet);
316 } else {
317 blk = img_open_file(id, filename, fmt, flags, true, quiet);
319 return blk;
323 static int add_old_style_options(const char *fmt, QemuOpts *opts,
324 const char *base_filename,
325 const char *base_fmt)
327 Error *err = NULL;
329 if (base_filename) {
330 qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &err);
331 if (err) {
332 error_report("Backing file not supported for file format '%s'",
333 fmt);
334 error_free(err);
335 return -1;
338 if (base_fmt) {
339 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &err);
340 if (err) {
341 error_report("Backing file format not supported for file "
342 "format '%s'", fmt);
343 error_free(err);
344 return -1;
347 return 0;
350 static int img_create(int argc, char **argv)
352 int c;
353 uint64_t img_size = -1;
354 const char *fmt = "raw";
355 const char *base_fmt = NULL;
356 const char *filename;
357 const char *base_filename = NULL;
358 char *options = NULL;
359 Error *local_err = NULL;
360 bool quiet = false;
362 for(;;) {
363 static const struct option long_options[] = {
364 {"help", no_argument, 0, 'h'},
365 {"object", required_argument, 0, OPTION_OBJECT},
366 {0, 0, 0, 0}
368 c = getopt_long(argc, argv, "F:b:f:he6o:q",
369 long_options, NULL);
370 if (c == -1) {
371 break;
373 switch(c) {
374 case '?':
375 case 'h':
376 help();
377 break;
378 case 'F':
379 base_fmt = optarg;
380 break;
381 case 'b':
382 base_filename = optarg;
383 break;
384 case 'f':
385 fmt = optarg;
386 break;
387 case 'e':
388 error_report("option -e is deprecated, please use \'-o "
389 "encryption\' instead!");
390 goto fail;
391 case '6':
392 error_report("option -6 is deprecated, please use \'-o "
393 "compat6\' instead!");
394 goto fail;
395 case 'o':
396 if (!is_valid_option_list(optarg)) {
397 error_report("Invalid option list: %s", optarg);
398 goto fail;
400 if (!options) {
401 options = g_strdup(optarg);
402 } else {
403 char *old_options = options;
404 options = g_strdup_printf("%s,%s", options, optarg);
405 g_free(old_options);
407 break;
408 case 'q':
409 quiet = true;
410 break;
411 case OPTION_OBJECT: {
412 QemuOpts *opts;
413 opts = qemu_opts_parse_noisily(&qemu_object_opts,
414 optarg, true);
415 if (!opts) {
416 goto fail;
418 } break;
422 /* Get the filename */
423 filename = (optind < argc) ? argv[optind] : NULL;
424 if (options && has_help_option(options)) {
425 g_free(options);
426 return print_block_option_help(filename, fmt);
429 if (optind >= argc) {
430 error_exit("Expecting image file name");
432 optind++;
434 if (qemu_opts_foreach(&qemu_object_opts,
435 user_creatable_add_opts_foreach,
436 NULL, &local_err)) {
437 error_report_err(local_err);
438 goto fail;
441 /* Get image size, if specified */
442 if (optind < argc) {
443 int64_t sval;
444 char *end;
445 sval = qemu_strtosz_suffix(argv[optind++], &end,
446 QEMU_STRTOSZ_DEFSUFFIX_B);
447 if (sval < 0 || *end) {
448 if (sval == -ERANGE) {
449 error_report("Image size must be less than 8 EiB!");
450 } else {
451 error_report("Invalid image size specified! You may use k, M, "
452 "G, T, P or E suffixes for ");
453 error_report("kilobytes, megabytes, gigabytes, terabytes, "
454 "petabytes and exabytes.");
456 goto fail;
458 img_size = (uint64_t)sval;
460 if (optind != argc) {
461 error_exit("Unexpected argument: %s", argv[optind]);
464 bdrv_img_create(filename, fmt, base_filename, base_fmt,
465 options, img_size, BDRV_O_FLAGS, &local_err, quiet);
466 if (local_err) {
467 error_reportf_err(local_err, "%s: ", filename);
468 goto fail;
471 g_free(options);
472 return 0;
474 fail:
475 g_free(options);
476 return 1;
479 static void dump_json_image_check(ImageCheck *check, bool quiet)
481 Error *local_err = NULL;
482 QString *str;
483 QmpOutputVisitor *ov = qmp_output_visitor_new();
484 QObject *obj;
485 visit_type_ImageCheck(qmp_output_get_visitor(ov), NULL, &check,
486 &local_err);
487 obj = qmp_output_get_qobject(ov);
488 str = qobject_to_json_pretty(obj);
489 assert(str != NULL);
490 qprintf(quiet, "%s\n", qstring_get_str(str));
491 qobject_decref(obj);
492 qmp_output_visitor_cleanup(ov);
493 QDECREF(str);
496 static void dump_human_image_check(ImageCheck *check, bool quiet)
498 if (!(check->corruptions || check->leaks || check->check_errors)) {
499 qprintf(quiet, "No errors were found on the image.\n");
500 } else {
501 if (check->corruptions) {
502 qprintf(quiet, "\n%" PRId64 " errors were found on the image.\n"
503 "Data may be corrupted, or further writes to the image "
504 "may corrupt it.\n",
505 check->corruptions);
508 if (check->leaks) {
509 qprintf(quiet,
510 "\n%" PRId64 " leaked clusters were found on the image.\n"
511 "This means waste of disk space, but no harm to data.\n",
512 check->leaks);
515 if (check->check_errors) {
516 qprintf(quiet,
517 "\n%" PRId64
518 " internal errors have occurred during the check.\n",
519 check->check_errors);
523 if (check->total_clusters != 0 && check->allocated_clusters != 0) {
524 qprintf(quiet, "%" PRId64 "/%" PRId64 " = %0.2f%% allocated, "
525 "%0.2f%% fragmented, %0.2f%% compressed clusters\n",
526 check->allocated_clusters, check->total_clusters,
527 check->allocated_clusters * 100.0 / check->total_clusters,
528 check->fragmented_clusters * 100.0 / check->allocated_clusters,
529 check->compressed_clusters * 100.0 /
530 check->allocated_clusters);
533 if (check->image_end_offset) {
534 qprintf(quiet,
535 "Image end offset: %" PRId64 "\n", check->image_end_offset);
539 static int collect_image_check(BlockDriverState *bs,
540 ImageCheck *check,
541 const char *filename,
542 const char *fmt,
543 int fix)
545 int ret;
546 BdrvCheckResult result;
548 ret = bdrv_check(bs, &result, fix);
549 if (ret < 0) {
550 return ret;
553 check->filename = g_strdup(filename);
554 check->format = g_strdup(bdrv_get_format_name(bs));
555 check->check_errors = result.check_errors;
556 check->corruptions = result.corruptions;
557 check->has_corruptions = result.corruptions != 0;
558 check->leaks = result.leaks;
559 check->has_leaks = result.leaks != 0;
560 check->corruptions_fixed = result.corruptions_fixed;
561 check->has_corruptions_fixed = result.corruptions != 0;
562 check->leaks_fixed = result.leaks_fixed;
563 check->has_leaks_fixed = result.leaks != 0;
564 check->image_end_offset = result.image_end_offset;
565 check->has_image_end_offset = result.image_end_offset != 0;
566 check->total_clusters = result.bfi.total_clusters;
567 check->has_total_clusters = result.bfi.total_clusters != 0;
568 check->allocated_clusters = result.bfi.allocated_clusters;
569 check->has_allocated_clusters = result.bfi.allocated_clusters != 0;
570 check->fragmented_clusters = result.bfi.fragmented_clusters;
571 check->has_fragmented_clusters = result.bfi.fragmented_clusters != 0;
572 check->compressed_clusters = result.bfi.compressed_clusters;
573 check->has_compressed_clusters = result.bfi.compressed_clusters != 0;
575 return 0;
579 * Checks an image for consistency. Exit codes:
581 * 0 - Check completed, image is good
582 * 1 - Check not completed because of internal errors
583 * 2 - Check completed, image is corrupted
584 * 3 - Check completed, image has leaked clusters, but is good otherwise
585 * 63 - Checks are not supported by the image format
587 static int img_check(int argc, char **argv)
589 int c, ret;
590 OutputFormat output_format = OFORMAT_HUMAN;
591 const char *filename, *fmt, *output, *cache;
592 BlockBackend *blk;
593 BlockDriverState *bs;
594 int fix = 0;
595 int flags = BDRV_O_FLAGS | BDRV_O_CHECK;
596 ImageCheck *check;
597 bool quiet = false;
598 Error *local_err = NULL;
599 bool image_opts = false;
601 fmt = NULL;
602 output = NULL;
603 cache = BDRV_DEFAULT_CACHE;
604 for(;;) {
605 int option_index = 0;
606 static const struct option long_options[] = {
607 {"help", no_argument, 0, 'h'},
608 {"format", required_argument, 0, 'f'},
609 {"repair", required_argument, 0, 'r'},
610 {"output", required_argument, 0, OPTION_OUTPUT},
611 {"object", required_argument, 0, OPTION_OBJECT},
612 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
613 {0, 0, 0, 0}
615 c = getopt_long(argc, argv, "hf:r:T:q",
616 long_options, &option_index);
617 if (c == -1) {
618 break;
620 switch(c) {
621 case '?':
622 case 'h':
623 help();
624 break;
625 case 'f':
626 fmt = optarg;
627 break;
628 case 'r':
629 flags |= BDRV_O_RDWR;
631 if (!strcmp(optarg, "leaks")) {
632 fix = BDRV_FIX_LEAKS;
633 } else if (!strcmp(optarg, "all")) {
634 fix = BDRV_FIX_LEAKS | BDRV_FIX_ERRORS;
635 } else {
636 error_exit("Unknown option value for -r "
637 "(expecting 'leaks' or 'all'): %s", optarg);
639 break;
640 case OPTION_OUTPUT:
641 output = optarg;
642 break;
643 case 'T':
644 cache = optarg;
645 break;
646 case 'q':
647 quiet = true;
648 break;
649 case OPTION_OBJECT: {
650 QemuOpts *opts;
651 opts = qemu_opts_parse_noisily(&qemu_object_opts,
652 optarg, true);
653 if (!opts) {
654 return 1;
656 } break;
657 case OPTION_IMAGE_OPTS:
658 image_opts = true;
659 break;
662 if (optind != argc - 1) {
663 error_exit("Expecting one image file name");
665 filename = argv[optind++];
667 if (output && !strcmp(output, "json")) {
668 output_format = OFORMAT_JSON;
669 } else if (output && !strcmp(output, "human")) {
670 output_format = OFORMAT_HUMAN;
671 } else if (output) {
672 error_report("--output must be used with human or json as argument.");
673 return 1;
676 if (qemu_opts_foreach(&qemu_object_opts,
677 user_creatable_add_opts_foreach,
678 NULL, &local_err)) {
679 error_report_err(local_err);
680 return 1;
683 ret = bdrv_parse_cache_flags(cache, &flags);
684 if (ret < 0) {
685 error_report("Invalid source cache option: %s", cache);
686 return 1;
689 blk = img_open("image", image_opts, filename, fmt, flags, true, quiet);
690 if (!blk) {
691 return 1;
693 bs = blk_bs(blk);
695 check = g_new0(ImageCheck, 1);
696 ret = collect_image_check(bs, check, filename, fmt, fix);
698 if (ret == -ENOTSUP) {
699 error_report("This image format does not support checks");
700 ret = 63;
701 goto fail;
704 if (check->corruptions_fixed || check->leaks_fixed) {
705 int corruptions_fixed, leaks_fixed;
707 leaks_fixed = check->leaks_fixed;
708 corruptions_fixed = check->corruptions_fixed;
710 if (output_format == OFORMAT_HUMAN) {
711 qprintf(quiet,
712 "The following inconsistencies were found and repaired:\n\n"
713 " %" PRId64 " leaked clusters\n"
714 " %" PRId64 " corruptions\n\n"
715 "Double checking the fixed image now...\n",
716 check->leaks_fixed,
717 check->corruptions_fixed);
720 ret = collect_image_check(bs, check, filename, fmt, 0);
722 check->leaks_fixed = leaks_fixed;
723 check->corruptions_fixed = corruptions_fixed;
726 if (!ret) {
727 switch (output_format) {
728 case OFORMAT_HUMAN:
729 dump_human_image_check(check, quiet);
730 break;
731 case OFORMAT_JSON:
732 dump_json_image_check(check, quiet);
733 break;
737 if (ret || check->check_errors) {
738 if (ret) {
739 error_report("Check failed: %s", strerror(-ret));
740 } else {
741 error_report("Check failed");
743 ret = 1;
744 goto fail;
747 if (check->corruptions) {
748 ret = 2;
749 } else if (check->leaks) {
750 ret = 3;
751 } else {
752 ret = 0;
755 fail:
756 qapi_free_ImageCheck(check);
757 blk_unref(blk);
758 return ret;
761 typedef struct CommonBlockJobCBInfo {
762 BlockDriverState *bs;
763 Error **errp;
764 } CommonBlockJobCBInfo;
766 static void common_block_job_cb(void *opaque, int ret)
768 CommonBlockJobCBInfo *cbi = opaque;
770 if (ret < 0) {
771 error_setg_errno(cbi->errp, -ret, "Block job failed");
775 static void run_block_job(BlockJob *job, Error **errp)
777 AioContext *aio_context = bdrv_get_aio_context(job->bs);
779 do {
780 aio_poll(aio_context, true);
781 qemu_progress_print(job->len ?
782 ((float)job->offset / job->len * 100.f) : 0.0f, 0);
783 } while (!job->ready);
785 block_job_complete_sync(job, errp);
787 /* A block job may finish instantaneously without publishing any progress,
788 * so just signal completion here */
789 qemu_progress_print(100.f, 0);
792 static int img_commit(int argc, char **argv)
794 int c, ret, flags;
795 const char *filename, *fmt, *cache, *base;
796 BlockBackend *blk;
797 BlockDriverState *bs, *base_bs;
798 bool progress = false, quiet = false, drop = false;
799 Error *local_err = NULL;
800 CommonBlockJobCBInfo cbi;
801 bool image_opts = false;
803 fmt = NULL;
804 cache = BDRV_DEFAULT_CACHE;
805 base = NULL;
806 for(;;) {
807 static const struct option long_options[] = {
808 {"help", no_argument, 0, 'h'},
809 {"object", required_argument, 0, OPTION_OBJECT},
810 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
811 {0, 0, 0, 0}
813 c = getopt_long(argc, argv, "f:ht:b:dpq",
814 long_options, NULL);
815 if (c == -1) {
816 break;
818 switch(c) {
819 case '?':
820 case 'h':
821 help();
822 break;
823 case 'f':
824 fmt = optarg;
825 break;
826 case 't':
827 cache = optarg;
828 break;
829 case 'b':
830 base = optarg;
831 /* -b implies -d */
832 drop = true;
833 break;
834 case 'd':
835 drop = true;
836 break;
837 case 'p':
838 progress = true;
839 break;
840 case 'q':
841 quiet = true;
842 break;
843 case OPTION_OBJECT: {
844 QemuOpts *opts;
845 opts = qemu_opts_parse_noisily(&qemu_object_opts,
846 optarg, true);
847 if (!opts) {
848 return 1;
850 } break;
851 case OPTION_IMAGE_OPTS:
852 image_opts = true;
853 break;
857 /* Progress is not shown in Quiet mode */
858 if (quiet) {
859 progress = false;
862 if (optind != argc - 1) {
863 error_exit("Expecting one image file name");
865 filename = argv[optind++];
867 if (qemu_opts_foreach(&qemu_object_opts,
868 user_creatable_add_opts_foreach,
869 NULL, &local_err)) {
870 error_report_err(local_err);
871 return 1;
874 flags = BDRV_O_RDWR | BDRV_O_UNMAP;
875 ret = bdrv_parse_cache_flags(cache, &flags);
876 if (ret < 0) {
877 error_report("Invalid cache option: %s", cache);
878 return 1;
881 blk = img_open("image", image_opts, filename, fmt, flags, true, quiet);
882 if (!blk) {
883 return 1;
885 bs = blk_bs(blk);
887 qemu_progress_init(progress, 1.f);
888 qemu_progress_print(0.f, 100);
890 if (base) {
891 base_bs = bdrv_find_backing_image(bs, base);
892 if (!base_bs) {
893 error_setg(&local_err, QERR_BASE_NOT_FOUND, base);
894 goto done;
896 } else {
897 /* This is different from QMP, which by default uses the deepest file in
898 * the backing chain (i.e., the very base); however, the traditional
899 * behavior of qemu-img commit is using the immediate backing file. */
900 base_bs = backing_bs(bs);
901 if (!base_bs) {
902 error_setg(&local_err, "Image does not have a backing file");
903 goto done;
907 cbi = (CommonBlockJobCBInfo){
908 .errp = &local_err,
909 .bs = bs,
912 commit_active_start(bs, base_bs, 0, BLOCKDEV_ON_ERROR_REPORT,
913 common_block_job_cb, &cbi, &local_err);
914 if (local_err) {
915 goto done;
918 /* When the block job completes, the BlockBackend reference will point to
919 * the old backing file. In order to avoid that the top image is already
920 * deleted, so we can still empty it afterwards, increment the reference
921 * counter here preemptively. */
922 if (!drop) {
923 bdrv_ref(bs);
926 run_block_job(bs->job, &local_err);
927 if (local_err) {
928 goto unref_backing;
931 if (!drop && bs->drv->bdrv_make_empty) {
932 ret = bs->drv->bdrv_make_empty(bs);
933 if (ret) {
934 error_setg_errno(&local_err, -ret, "Could not empty %s",
935 filename);
936 goto unref_backing;
940 unref_backing:
941 if (!drop) {
942 bdrv_unref(bs);
945 done:
946 qemu_progress_end();
948 blk_unref(blk);
950 if (local_err) {
951 error_report_err(local_err);
952 return 1;
955 qprintf(quiet, "Image committed.\n");
956 return 0;
960 * Returns true iff the first sector pointed to by 'buf' contains at least
961 * a non-NUL byte.
963 * 'pnum' is set to the number of sectors (including and immediately following
964 * the first one) that are known to be in the same allocated/unallocated state.
966 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
968 bool is_zero;
969 int i;
971 if (n <= 0) {
972 *pnum = 0;
973 return 0;
975 is_zero = buffer_is_zero(buf, 512);
976 for(i = 1; i < n; i++) {
977 buf += 512;
978 if (is_zero != buffer_is_zero(buf, 512)) {
979 break;
982 *pnum = i;
983 return !is_zero;
987 * Like is_allocated_sectors, but if the buffer starts with a used sector,
988 * up to 'min' consecutive sectors containing zeros are ignored. This avoids
989 * breaking up write requests for only small sparse areas.
991 static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
992 int min)
994 int ret;
995 int num_checked, num_used;
997 if (n < min) {
998 min = n;
1001 ret = is_allocated_sectors(buf, n, pnum);
1002 if (!ret) {
1003 return ret;
1006 num_used = *pnum;
1007 buf += BDRV_SECTOR_SIZE * *pnum;
1008 n -= *pnum;
1009 num_checked = num_used;
1011 while (n > 0) {
1012 ret = is_allocated_sectors(buf, n, pnum);
1014 buf += BDRV_SECTOR_SIZE * *pnum;
1015 n -= *pnum;
1016 num_checked += *pnum;
1017 if (ret) {
1018 num_used = num_checked;
1019 } else if (*pnum >= min) {
1020 break;
1024 *pnum = num_used;
1025 return 1;
1029 * Compares two buffers sector by sector. Returns 0 if the first sector of both
1030 * buffers matches, non-zero otherwise.
1032 * pnum is set to the number of sectors (including and immediately following
1033 * the first one) that are known to have the same comparison result
1035 static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
1036 int *pnum)
1038 bool res;
1039 int i;
1041 if (n <= 0) {
1042 *pnum = 0;
1043 return 0;
1046 res = !!memcmp(buf1, buf2, 512);
1047 for(i = 1; i < n; i++) {
1048 buf1 += 512;
1049 buf2 += 512;
1051 if (!!memcmp(buf1, buf2, 512) != res) {
1052 break;
1056 *pnum = i;
1057 return res;
1060 #define IO_BUF_SIZE (2 * 1024 * 1024)
1062 static int64_t sectors_to_bytes(int64_t sectors)
1064 return sectors << BDRV_SECTOR_BITS;
1067 static int64_t sectors_to_process(int64_t total, int64_t from)
1069 return MIN(total - from, IO_BUF_SIZE >> BDRV_SECTOR_BITS);
1073 * Check if passed sectors are empty (not allocated or contain only 0 bytes)
1075 * Returns 0 in case sectors are filled with 0, 1 if sectors contain non-zero
1076 * data and negative value on error.
1078 * @param blk: BlockBackend for the image
1079 * @param sect_num: Number of first sector to check
1080 * @param sect_count: Number of sectors to check
1081 * @param filename: Name of disk file we are checking (logging purpose)
1082 * @param buffer: Allocated buffer for storing read data
1083 * @param quiet: Flag for quiet mode
1085 static int check_empty_sectors(BlockBackend *blk, int64_t sect_num,
1086 int sect_count, const char *filename,
1087 uint8_t *buffer, bool quiet)
1089 int pnum, ret = 0;
1090 ret = blk_read(blk, sect_num, buffer, sect_count);
1091 if (ret < 0) {
1092 error_report("Error while reading offset %" PRId64 " of %s: %s",
1093 sectors_to_bytes(sect_num), filename, strerror(-ret));
1094 return ret;
1096 ret = is_allocated_sectors(buffer, sect_count, &pnum);
1097 if (ret || pnum != sect_count) {
1098 qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
1099 sectors_to_bytes(ret ? sect_num : sect_num + pnum));
1100 return 1;
1103 return 0;
1107 * Compares two images. Exit codes:
1109 * 0 - Images are identical
1110 * 1 - Images differ
1111 * >1 - Error occurred
1113 static int img_compare(int argc, char **argv)
1115 const char *fmt1 = NULL, *fmt2 = NULL, *cache, *filename1, *filename2;
1116 BlockBackend *blk1, *blk2;
1117 BlockDriverState *bs1, *bs2;
1118 int64_t total_sectors1, total_sectors2;
1119 uint8_t *buf1 = NULL, *buf2 = NULL;
1120 int pnum1, pnum2;
1121 int allocated1, allocated2;
1122 int ret = 0; /* return value - 0 Ident, 1 Different, >1 Error */
1123 bool progress = false, quiet = false, strict = false;
1124 int flags;
1125 int64_t total_sectors;
1126 int64_t sector_num = 0;
1127 int64_t nb_sectors;
1128 int c, pnum;
1129 uint64_t progress_base;
1130 Error *local_err = NULL;
1131 bool image_opts = false;
1133 cache = BDRV_DEFAULT_CACHE;
1134 for (;;) {
1135 static const struct option long_options[] = {
1136 {"help", no_argument, 0, 'h'},
1137 {"object", required_argument, 0, OPTION_OBJECT},
1138 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
1139 {0, 0, 0, 0}
1141 c = getopt_long(argc, argv, "hf:F:T:pqs",
1142 long_options, NULL);
1143 if (c == -1) {
1144 break;
1146 switch (c) {
1147 case '?':
1148 case 'h':
1149 help();
1150 break;
1151 case 'f':
1152 fmt1 = optarg;
1153 break;
1154 case 'F':
1155 fmt2 = optarg;
1156 break;
1157 case 'T':
1158 cache = optarg;
1159 break;
1160 case 'p':
1161 progress = true;
1162 break;
1163 case 'q':
1164 quiet = true;
1165 break;
1166 case 's':
1167 strict = true;
1168 break;
1169 case OPTION_OBJECT: {
1170 QemuOpts *opts;
1171 opts = qemu_opts_parse_noisily(&qemu_object_opts,
1172 optarg, true);
1173 if (!opts) {
1174 ret = 2;
1175 goto out4;
1177 } break;
1178 case OPTION_IMAGE_OPTS:
1179 image_opts = true;
1180 break;
1184 /* Progress is not shown in Quiet mode */
1185 if (quiet) {
1186 progress = false;
1190 if (optind != argc - 2) {
1191 error_exit("Expecting two image file names");
1193 filename1 = argv[optind++];
1194 filename2 = argv[optind++];
1196 if (qemu_opts_foreach(&qemu_object_opts,
1197 user_creatable_add_opts_foreach,
1198 NULL, &local_err)) {
1199 error_report_err(local_err);
1200 ret = 2;
1201 goto out4;
1204 /* Initialize before goto out */
1205 qemu_progress_init(progress, 2.0);
1207 flags = BDRV_O_FLAGS;
1208 ret = bdrv_parse_cache_flags(cache, &flags);
1209 if (ret < 0) {
1210 error_report("Invalid source cache option: %s", cache);
1211 ret = 2;
1212 goto out3;
1215 blk1 = img_open("image_1", image_opts, filename1, fmt1, flags, true, quiet);
1216 if (!blk1) {
1217 ret = 2;
1218 goto out3;
1221 blk2 = img_open("image_2", image_opts, filename2, fmt2, flags, true, quiet);
1222 if (!blk2) {
1223 ret = 2;
1224 goto out2;
1226 bs1 = blk_bs(blk1);
1227 bs2 = blk_bs(blk2);
1229 buf1 = blk_blockalign(blk1, IO_BUF_SIZE);
1230 buf2 = blk_blockalign(blk2, IO_BUF_SIZE);
1231 total_sectors1 = blk_nb_sectors(blk1);
1232 if (total_sectors1 < 0) {
1233 error_report("Can't get size of %s: %s",
1234 filename1, strerror(-total_sectors1));
1235 ret = 4;
1236 goto out;
1238 total_sectors2 = blk_nb_sectors(blk2);
1239 if (total_sectors2 < 0) {
1240 error_report("Can't get size of %s: %s",
1241 filename2, strerror(-total_sectors2));
1242 ret = 4;
1243 goto out;
1245 total_sectors = MIN(total_sectors1, total_sectors2);
1246 progress_base = MAX(total_sectors1, total_sectors2);
1248 qemu_progress_print(0, 100);
1250 if (strict && total_sectors1 != total_sectors2) {
1251 ret = 1;
1252 qprintf(quiet, "Strict mode: Image size mismatch!\n");
1253 goto out;
1256 for (;;) {
1257 int64_t status1, status2;
1258 BlockDriverState *file;
1260 nb_sectors = sectors_to_process(total_sectors, sector_num);
1261 if (nb_sectors <= 0) {
1262 break;
1264 status1 = bdrv_get_block_status_above(bs1, NULL, sector_num,
1265 total_sectors1 - sector_num,
1266 &pnum1, &file);
1267 if (status1 < 0) {
1268 ret = 3;
1269 error_report("Sector allocation test failed for %s", filename1);
1270 goto out;
1272 allocated1 = status1 & BDRV_BLOCK_ALLOCATED;
1274 status2 = bdrv_get_block_status_above(bs2, NULL, sector_num,
1275 total_sectors2 - sector_num,
1276 &pnum2, &file);
1277 if (status2 < 0) {
1278 ret = 3;
1279 error_report("Sector allocation test failed for %s", filename2);
1280 goto out;
1282 allocated2 = status2 & BDRV_BLOCK_ALLOCATED;
1283 if (pnum1) {
1284 nb_sectors = MIN(nb_sectors, pnum1);
1286 if (pnum2) {
1287 nb_sectors = MIN(nb_sectors, pnum2);
1290 if (strict) {
1291 if ((status1 & ~BDRV_BLOCK_OFFSET_MASK) !=
1292 (status2 & ~BDRV_BLOCK_OFFSET_MASK)) {
1293 ret = 1;
1294 qprintf(quiet, "Strict mode: Offset %" PRId64
1295 " block status mismatch!\n",
1296 sectors_to_bytes(sector_num));
1297 goto out;
1300 if ((status1 & BDRV_BLOCK_ZERO) && (status2 & BDRV_BLOCK_ZERO)) {
1301 nb_sectors = MIN(pnum1, pnum2);
1302 } else if (allocated1 == allocated2) {
1303 if (allocated1) {
1304 ret = blk_read(blk1, sector_num, buf1, nb_sectors);
1305 if (ret < 0) {
1306 error_report("Error while reading offset %" PRId64 " of %s:"
1307 " %s", sectors_to_bytes(sector_num), filename1,
1308 strerror(-ret));
1309 ret = 4;
1310 goto out;
1312 ret = blk_read(blk2, sector_num, buf2, nb_sectors);
1313 if (ret < 0) {
1314 error_report("Error while reading offset %" PRId64
1315 " of %s: %s", sectors_to_bytes(sector_num),
1316 filename2, strerror(-ret));
1317 ret = 4;
1318 goto out;
1320 ret = compare_sectors(buf1, buf2, nb_sectors, &pnum);
1321 if (ret || pnum != nb_sectors) {
1322 qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
1323 sectors_to_bytes(
1324 ret ? sector_num : sector_num + pnum));
1325 ret = 1;
1326 goto out;
1329 } else {
1331 if (allocated1) {
1332 ret = check_empty_sectors(blk1, sector_num, nb_sectors,
1333 filename1, buf1, quiet);
1334 } else {
1335 ret = check_empty_sectors(blk2, sector_num, nb_sectors,
1336 filename2, buf1, quiet);
1338 if (ret) {
1339 if (ret < 0) {
1340 error_report("Error while reading offset %" PRId64 ": %s",
1341 sectors_to_bytes(sector_num), strerror(-ret));
1342 ret = 4;
1344 goto out;
1347 sector_num += nb_sectors;
1348 qemu_progress_print(((float) nb_sectors / progress_base)*100, 100);
1351 if (total_sectors1 != total_sectors2) {
1352 BlockBackend *blk_over;
1353 int64_t total_sectors_over;
1354 const char *filename_over;
1356 qprintf(quiet, "Warning: Image size mismatch!\n");
1357 if (total_sectors1 > total_sectors2) {
1358 total_sectors_over = total_sectors1;
1359 blk_over = blk1;
1360 filename_over = filename1;
1361 } else {
1362 total_sectors_over = total_sectors2;
1363 blk_over = blk2;
1364 filename_over = filename2;
1367 for (;;) {
1368 nb_sectors = sectors_to_process(total_sectors_over, sector_num);
1369 if (nb_sectors <= 0) {
1370 break;
1372 ret = bdrv_is_allocated_above(blk_bs(blk_over), NULL, sector_num,
1373 nb_sectors, &pnum);
1374 if (ret < 0) {
1375 ret = 3;
1376 error_report("Sector allocation test failed for %s",
1377 filename_over);
1378 goto out;
1381 nb_sectors = pnum;
1382 if (ret) {
1383 ret = check_empty_sectors(blk_over, sector_num, nb_sectors,
1384 filename_over, buf1, quiet);
1385 if (ret) {
1386 if (ret < 0) {
1387 error_report("Error while reading offset %" PRId64
1388 " of %s: %s", sectors_to_bytes(sector_num),
1389 filename_over, strerror(-ret));
1390 ret = 4;
1392 goto out;
1395 sector_num += nb_sectors;
1396 qemu_progress_print(((float) nb_sectors / progress_base)*100, 100);
1400 qprintf(quiet, "Images are identical.\n");
1401 ret = 0;
1403 out:
1404 qemu_vfree(buf1);
1405 qemu_vfree(buf2);
1406 blk_unref(blk2);
1407 out2:
1408 blk_unref(blk1);
1409 out3:
1410 qemu_progress_end();
1411 out4:
1412 return ret;
1415 enum ImgConvertBlockStatus {
1416 BLK_DATA,
1417 BLK_ZERO,
1418 BLK_BACKING_FILE,
1421 typedef struct ImgConvertState {
1422 BlockBackend **src;
1423 int64_t *src_sectors;
1424 int src_cur, src_num;
1425 int64_t src_cur_offset;
1426 int64_t total_sectors;
1427 int64_t allocated_sectors;
1428 enum ImgConvertBlockStatus status;
1429 int64_t sector_next_status;
1430 BlockBackend *target;
1431 bool has_zero_init;
1432 bool compressed;
1433 bool target_has_backing;
1434 int min_sparse;
1435 size_t cluster_sectors;
1436 size_t buf_sectors;
1437 } ImgConvertState;
1439 static void convert_select_part(ImgConvertState *s, int64_t sector_num)
1441 assert(sector_num >= s->src_cur_offset);
1442 while (sector_num - s->src_cur_offset >= s->src_sectors[s->src_cur]) {
1443 s->src_cur_offset += s->src_sectors[s->src_cur];
1444 s->src_cur++;
1445 assert(s->src_cur < s->src_num);
1449 static int convert_iteration_sectors(ImgConvertState *s, int64_t sector_num)
1451 int64_t ret;
1452 int n;
1454 convert_select_part(s, sector_num);
1456 assert(s->total_sectors > sector_num);
1457 n = MIN(s->total_sectors - sector_num, BDRV_REQUEST_MAX_SECTORS);
1459 if (s->sector_next_status <= sector_num) {
1460 BlockDriverState *file;
1461 ret = bdrv_get_block_status(blk_bs(s->src[s->src_cur]),
1462 sector_num - s->src_cur_offset,
1463 n, &n, &file);
1464 if (ret < 0) {
1465 return ret;
1468 if (ret & BDRV_BLOCK_ZERO) {
1469 s->status = BLK_ZERO;
1470 } else if (ret & BDRV_BLOCK_DATA) {
1471 s->status = BLK_DATA;
1472 } else if (!s->target_has_backing) {
1473 /* Without a target backing file we must copy over the contents of
1474 * the backing file as well. */
1475 /* TODO Check block status of the backing file chain to avoid
1476 * needlessly reading zeroes and limiting the iteration to the
1477 * buffer size */
1478 s->status = BLK_DATA;
1479 } else {
1480 s->status = BLK_BACKING_FILE;
1483 s->sector_next_status = sector_num + n;
1486 n = MIN(n, s->sector_next_status - sector_num);
1487 if (s->status == BLK_DATA) {
1488 n = MIN(n, s->buf_sectors);
1491 /* We need to write complete clusters for compressed images, so if an
1492 * unallocated area is shorter than that, we must consider the whole
1493 * cluster allocated. */
1494 if (s->compressed) {
1495 if (n < s->cluster_sectors) {
1496 n = MIN(s->cluster_sectors, s->total_sectors - sector_num);
1497 s->status = BLK_DATA;
1498 } else {
1499 n = QEMU_ALIGN_DOWN(n, s->cluster_sectors);
1503 return n;
1506 static int convert_read(ImgConvertState *s, int64_t sector_num, int nb_sectors,
1507 uint8_t *buf)
1509 int n;
1510 int ret;
1512 if (s->status == BLK_ZERO || s->status == BLK_BACKING_FILE) {
1513 return 0;
1516 assert(nb_sectors <= s->buf_sectors);
1517 while (nb_sectors > 0) {
1518 BlockBackend *blk;
1519 int64_t bs_sectors;
1521 /* In the case of compression with multiple source files, we can get a
1522 * nb_sectors that spreads into the next part. So we must be able to
1523 * read across multiple BDSes for one convert_read() call. */
1524 convert_select_part(s, sector_num);
1525 blk = s->src[s->src_cur];
1526 bs_sectors = s->src_sectors[s->src_cur];
1528 n = MIN(nb_sectors, bs_sectors - (sector_num - s->src_cur_offset));
1529 ret = blk_read(blk, sector_num - s->src_cur_offset, buf, n);
1530 if (ret < 0) {
1531 return ret;
1534 sector_num += n;
1535 nb_sectors -= n;
1536 buf += n * BDRV_SECTOR_SIZE;
1539 return 0;
1542 static int convert_write(ImgConvertState *s, int64_t sector_num, int nb_sectors,
1543 const uint8_t *buf)
1545 int ret;
1547 while (nb_sectors > 0) {
1548 int n = nb_sectors;
1550 switch (s->status) {
1551 case BLK_BACKING_FILE:
1552 /* If we have a backing file, leave clusters unallocated that are
1553 * unallocated in the source image, so that the backing file is
1554 * visible at the respective offset. */
1555 assert(s->target_has_backing);
1556 break;
1558 case BLK_DATA:
1559 /* We must always write compressed clusters as a whole, so don't
1560 * try to find zeroed parts in the buffer. We can only save the
1561 * write if the buffer is completely zeroed and we're allowed to
1562 * keep the target sparse. */
1563 if (s->compressed) {
1564 if (s->has_zero_init && s->min_sparse &&
1565 buffer_is_zero(buf, n * BDRV_SECTOR_SIZE))
1567 assert(!s->target_has_backing);
1568 break;
1571 ret = blk_write_compressed(s->target, sector_num, buf, n);
1572 if (ret < 0) {
1573 return ret;
1575 break;
1578 /* If there is real non-zero data or we're told to keep the target
1579 * fully allocated (-S 0), we must write it. Otherwise we can treat
1580 * it as zero sectors. */
1581 if (!s->min_sparse ||
1582 is_allocated_sectors_min(buf, n, &n, s->min_sparse))
1584 ret = blk_write(s->target, sector_num, buf, n);
1585 if (ret < 0) {
1586 return ret;
1588 break;
1590 /* fall-through */
1592 case BLK_ZERO:
1593 if (s->has_zero_init) {
1594 break;
1596 ret = blk_write_zeroes(s->target, sector_num, n, 0);
1597 if (ret < 0) {
1598 return ret;
1600 break;
1603 sector_num += n;
1604 nb_sectors -= n;
1605 buf += n * BDRV_SECTOR_SIZE;
1608 return 0;
1611 static int convert_do_copy(ImgConvertState *s)
1613 uint8_t *buf = NULL;
1614 int64_t sector_num, allocated_done;
1615 int ret;
1616 int n;
1618 /* Check whether we have zero initialisation or can get it efficiently */
1619 s->has_zero_init = s->min_sparse && !s->target_has_backing
1620 ? bdrv_has_zero_init(blk_bs(s->target))
1621 : false;
1623 if (!s->has_zero_init && !s->target_has_backing &&
1624 bdrv_can_write_zeroes_with_unmap(blk_bs(s->target)))
1626 ret = bdrv_make_zero(blk_bs(s->target), BDRV_REQ_MAY_UNMAP);
1627 if (ret == 0) {
1628 s->has_zero_init = true;
1632 /* Allocate buffer for copied data. For compressed images, only one cluster
1633 * can be copied at a time. */
1634 if (s->compressed) {
1635 if (s->cluster_sectors <= 0 || s->cluster_sectors > s->buf_sectors) {
1636 error_report("invalid cluster size");
1637 ret = -EINVAL;
1638 goto fail;
1640 s->buf_sectors = s->cluster_sectors;
1642 buf = blk_blockalign(s->target, s->buf_sectors * BDRV_SECTOR_SIZE);
1644 /* Calculate allocated sectors for progress */
1645 s->allocated_sectors = 0;
1646 sector_num = 0;
1647 while (sector_num < s->total_sectors) {
1648 n = convert_iteration_sectors(s, sector_num);
1649 if (n < 0) {
1650 ret = n;
1651 goto fail;
1653 if (s->status == BLK_DATA) {
1654 s->allocated_sectors += n;
1656 sector_num += n;
1659 /* Do the copy */
1660 s->src_cur = 0;
1661 s->src_cur_offset = 0;
1662 s->sector_next_status = 0;
1664 sector_num = 0;
1665 allocated_done = 0;
1667 while (sector_num < s->total_sectors) {
1668 n = convert_iteration_sectors(s, sector_num);
1669 if (n < 0) {
1670 ret = n;
1671 goto fail;
1673 if (s->status == BLK_DATA) {
1674 allocated_done += n;
1675 qemu_progress_print(100.0 * allocated_done / s->allocated_sectors,
1679 ret = convert_read(s, sector_num, n, buf);
1680 if (ret < 0) {
1681 error_report("error while reading sector %" PRId64
1682 ": %s", sector_num, strerror(-ret));
1683 goto fail;
1686 ret = convert_write(s, sector_num, n, buf);
1687 if (ret < 0) {
1688 error_report("error while writing sector %" PRId64
1689 ": %s", sector_num, strerror(-ret));
1690 goto fail;
1693 sector_num += n;
1696 if (s->compressed) {
1697 /* signal EOF to align */
1698 ret = blk_write_compressed(s->target, 0, NULL, 0);
1699 if (ret < 0) {
1700 goto fail;
1704 ret = 0;
1705 fail:
1706 qemu_vfree(buf);
1707 return ret;
1710 static int img_convert(int argc, char **argv)
1712 int c, bs_n, bs_i, compress, cluster_sectors, skip_create;
1713 int64_t ret = 0;
1714 int progress = 0, flags, src_flags;
1715 const char *fmt, *out_fmt, *cache, *src_cache, *out_baseimg, *out_filename;
1716 BlockDriver *drv, *proto_drv;
1717 BlockBackend **blk = NULL, *out_blk = NULL;
1718 BlockDriverState **bs = NULL, *out_bs = NULL;
1719 int64_t total_sectors;
1720 int64_t *bs_sectors = NULL;
1721 size_t bufsectors = IO_BUF_SIZE / BDRV_SECTOR_SIZE;
1722 BlockDriverInfo bdi;
1723 QemuOpts *opts = NULL;
1724 QemuOptsList *create_opts = NULL;
1725 const char *out_baseimg_param;
1726 char *options = NULL;
1727 const char *snapshot_name = NULL;
1728 int min_sparse = 8; /* Need at least 4k of zeros for sparse detection */
1729 bool quiet = false;
1730 Error *local_err = NULL;
1731 QemuOpts *sn_opts = NULL;
1732 ImgConvertState state;
1733 bool image_opts = false;
1735 fmt = NULL;
1736 out_fmt = "raw";
1737 cache = "unsafe";
1738 src_cache = BDRV_DEFAULT_CACHE;
1739 out_baseimg = NULL;
1740 compress = 0;
1741 skip_create = 0;
1742 for(;;) {
1743 static const struct option long_options[] = {
1744 {"help", no_argument, 0, 'h'},
1745 {"object", required_argument, 0, OPTION_OBJECT},
1746 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
1747 {0, 0, 0, 0}
1749 c = getopt_long(argc, argv, "hf:O:B:ce6o:s:l:S:pt:T:qn",
1750 long_options, NULL);
1751 if (c == -1) {
1752 break;
1754 switch(c) {
1755 case '?':
1756 case 'h':
1757 help();
1758 break;
1759 case 'f':
1760 fmt = optarg;
1761 break;
1762 case 'O':
1763 out_fmt = optarg;
1764 break;
1765 case 'B':
1766 out_baseimg = optarg;
1767 break;
1768 case 'c':
1769 compress = 1;
1770 break;
1771 case 'e':
1772 error_report("option -e is deprecated, please use \'-o "
1773 "encryption\' instead!");
1774 ret = -1;
1775 goto fail_getopt;
1776 case '6':
1777 error_report("option -6 is deprecated, please use \'-o "
1778 "compat6\' instead!");
1779 ret = -1;
1780 goto fail_getopt;
1781 case 'o':
1782 if (!is_valid_option_list(optarg)) {
1783 error_report("Invalid option list: %s", optarg);
1784 ret = -1;
1785 goto fail_getopt;
1787 if (!options) {
1788 options = g_strdup(optarg);
1789 } else {
1790 char *old_options = options;
1791 options = g_strdup_printf("%s,%s", options, optarg);
1792 g_free(old_options);
1794 break;
1795 case 's':
1796 snapshot_name = optarg;
1797 break;
1798 case 'l':
1799 if (strstart(optarg, SNAPSHOT_OPT_BASE, NULL)) {
1800 sn_opts = qemu_opts_parse_noisily(&internal_snapshot_opts,
1801 optarg, false);
1802 if (!sn_opts) {
1803 error_report("Failed in parsing snapshot param '%s'",
1804 optarg);
1805 ret = -1;
1806 goto fail_getopt;
1808 } else {
1809 snapshot_name = optarg;
1811 break;
1812 case 'S':
1814 int64_t sval;
1815 char *end;
1816 sval = qemu_strtosz_suffix(optarg, &end, QEMU_STRTOSZ_DEFSUFFIX_B);
1817 if (sval < 0 || *end) {
1818 error_report("Invalid minimum zero buffer size for sparse output specified");
1819 ret = -1;
1820 goto fail_getopt;
1823 min_sparse = sval / BDRV_SECTOR_SIZE;
1824 break;
1826 case 'p':
1827 progress = 1;
1828 break;
1829 case 't':
1830 cache = optarg;
1831 break;
1832 case 'T':
1833 src_cache = optarg;
1834 break;
1835 case 'q':
1836 quiet = true;
1837 break;
1838 case 'n':
1839 skip_create = 1;
1840 break;
1841 case OPTION_OBJECT:
1842 opts = qemu_opts_parse_noisily(&qemu_object_opts,
1843 optarg, true);
1844 if (!opts) {
1845 goto fail_getopt;
1847 break;
1848 case OPTION_IMAGE_OPTS:
1849 image_opts = true;
1850 break;
1854 if (qemu_opts_foreach(&qemu_object_opts,
1855 user_creatable_add_opts_foreach,
1856 NULL, &local_err)) {
1857 error_report_err(local_err);
1858 goto fail_getopt;
1861 /* Initialize before goto out */
1862 if (quiet) {
1863 progress = 0;
1865 qemu_progress_init(progress, 1.0);
1867 bs_n = argc - optind - 1;
1868 out_filename = bs_n >= 1 ? argv[argc - 1] : NULL;
1870 if (options && has_help_option(options)) {
1871 ret = print_block_option_help(out_filename, out_fmt);
1872 goto out;
1875 if (bs_n < 1) {
1876 error_exit("Must specify image file name");
1880 if (bs_n > 1 && out_baseimg) {
1881 error_report("-B makes no sense when concatenating multiple input "
1882 "images");
1883 ret = -1;
1884 goto out;
1887 src_flags = BDRV_O_FLAGS;
1888 ret = bdrv_parse_cache_flags(src_cache, &src_flags);
1889 if (ret < 0) {
1890 error_report("Invalid source cache option: %s", src_cache);
1891 goto out;
1894 qemu_progress_print(0, 100);
1896 blk = g_new0(BlockBackend *, bs_n);
1897 bs = g_new0(BlockDriverState *, bs_n);
1898 bs_sectors = g_new(int64_t, bs_n);
1900 total_sectors = 0;
1901 for (bs_i = 0; bs_i < bs_n; bs_i++) {
1902 char *id = bs_n > 1 ? g_strdup_printf("source_%d", bs_i)
1903 : g_strdup("source");
1904 blk[bs_i] = img_open(id, image_opts, argv[optind + bs_i],
1905 fmt, src_flags, true, quiet);
1906 g_free(id);
1907 if (!blk[bs_i]) {
1908 ret = -1;
1909 goto out;
1911 bs[bs_i] = blk_bs(blk[bs_i]);
1912 bs_sectors[bs_i] = blk_nb_sectors(blk[bs_i]);
1913 if (bs_sectors[bs_i] < 0) {
1914 error_report("Could not get size of %s: %s",
1915 argv[optind + bs_i], strerror(-bs_sectors[bs_i]));
1916 ret = -1;
1917 goto out;
1919 total_sectors += bs_sectors[bs_i];
1922 if (sn_opts) {
1923 ret = bdrv_snapshot_load_tmp(bs[0],
1924 qemu_opt_get(sn_opts, SNAPSHOT_OPT_ID),
1925 qemu_opt_get(sn_opts, SNAPSHOT_OPT_NAME),
1926 &local_err);
1927 } else if (snapshot_name != NULL) {
1928 if (bs_n > 1) {
1929 error_report("No support for concatenating multiple snapshot");
1930 ret = -1;
1931 goto out;
1934 bdrv_snapshot_load_tmp_by_id_or_name(bs[0], snapshot_name, &local_err);
1936 if (local_err) {
1937 error_reportf_err(local_err, "Failed to load snapshot: ");
1938 ret = -1;
1939 goto out;
1942 /* Find driver and parse its options */
1943 drv = bdrv_find_format(out_fmt);
1944 if (!drv) {
1945 error_report("Unknown file format '%s'", out_fmt);
1946 ret = -1;
1947 goto out;
1950 proto_drv = bdrv_find_protocol(out_filename, true, &local_err);
1951 if (!proto_drv) {
1952 error_report_err(local_err);
1953 ret = -1;
1954 goto out;
1957 if (!skip_create) {
1958 if (!drv->create_opts) {
1959 error_report("Format driver '%s' does not support image creation",
1960 drv->format_name);
1961 ret = -1;
1962 goto out;
1965 if (!proto_drv->create_opts) {
1966 error_report("Protocol driver '%s' does not support image creation",
1967 proto_drv->format_name);
1968 ret = -1;
1969 goto out;
1972 create_opts = qemu_opts_append(create_opts, drv->create_opts);
1973 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
1975 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
1976 if (options) {
1977 qemu_opts_do_parse(opts, options, NULL, &local_err);
1978 if (local_err) {
1979 error_report_err(local_err);
1980 ret = -1;
1981 goto out;
1985 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_sectors * 512,
1986 &error_abort);
1987 ret = add_old_style_options(out_fmt, opts, out_baseimg, NULL);
1988 if (ret < 0) {
1989 goto out;
1993 /* Get backing file name if -o backing_file was used */
1994 out_baseimg_param = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
1995 if (out_baseimg_param) {
1996 out_baseimg = out_baseimg_param;
1999 /* Check if compression is supported */
2000 if (compress) {
2001 bool encryption =
2002 qemu_opt_get_bool(opts, BLOCK_OPT_ENCRYPT, false);
2003 const char *preallocation =
2004 qemu_opt_get(opts, BLOCK_OPT_PREALLOC);
2006 if (!drv->bdrv_write_compressed) {
2007 error_report("Compression not supported for this file format");
2008 ret = -1;
2009 goto out;
2012 if (encryption) {
2013 error_report("Compression and encryption not supported at "
2014 "the same time");
2015 ret = -1;
2016 goto out;
2019 if (preallocation
2020 && strcmp(preallocation, "off"))
2022 error_report("Compression and preallocation not supported at "
2023 "the same time");
2024 ret = -1;
2025 goto out;
2029 if (!skip_create) {
2030 /* Create the new image */
2031 ret = bdrv_create(drv, out_filename, opts, &local_err);
2032 if (ret < 0) {
2033 error_reportf_err(local_err, "%s: error while converting %s: ",
2034 out_filename, out_fmt);
2035 goto out;
2039 flags = min_sparse ? (BDRV_O_RDWR | BDRV_O_UNMAP) : BDRV_O_RDWR;
2040 ret = bdrv_parse_cache_flags(cache, &flags);
2041 if (ret < 0) {
2042 error_report("Invalid cache option: %s", cache);
2043 goto out;
2046 /* XXX we should allow --image-opts to trigger use of
2047 * img_open() here, but then we have trouble with
2048 * the bdrv_create() call which takes different params.
2049 * Not critical right now, so fix can wait...
2051 out_blk = img_open_file("target", out_filename,
2052 out_fmt, flags, true, quiet);
2053 if (!out_blk) {
2054 ret = -1;
2055 goto out;
2057 out_bs = blk_bs(out_blk);
2059 /* increase bufsectors from the default 4096 (2M) if opt_transfer_length
2060 * or discard_alignment of the out_bs is greater. Limit to 32768 (16MB)
2061 * as maximum. */
2062 bufsectors = MIN(32768,
2063 MAX(bufsectors, MAX(out_bs->bl.opt_transfer_length,
2064 out_bs->bl.discard_alignment))
2067 if (skip_create) {
2068 int64_t output_sectors = blk_nb_sectors(out_blk);
2069 if (output_sectors < 0) {
2070 error_report("unable to get output image length: %s",
2071 strerror(-output_sectors));
2072 ret = -1;
2073 goto out;
2074 } else if (output_sectors < total_sectors) {
2075 error_report("output file is smaller than input file");
2076 ret = -1;
2077 goto out;
2081 cluster_sectors = 0;
2082 ret = bdrv_get_info(out_bs, &bdi);
2083 if (ret < 0) {
2084 if (compress) {
2085 error_report("could not get block driver info");
2086 goto out;
2088 } else {
2089 compress = compress || bdi.needs_compressed_writes;
2090 cluster_sectors = bdi.cluster_size / BDRV_SECTOR_SIZE;
2093 state = (ImgConvertState) {
2094 .src = blk,
2095 .src_sectors = bs_sectors,
2096 .src_num = bs_n,
2097 .total_sectors = total_sectors,
2098 .target = out_blk,
2099 .compressed = compress,
2100 .target_has_backing = (bool) out_baseimg,
2101 .min_sparse = min_sparse,
2102 .cluster_sectors = cluster_sectors,
2103 .buf_sectors = bufsectors,
2105 ret = convert_do_copy(&state);
2107 out:
2108 if (!ret) {
2109 qemu_progress_print(100, 0);
2111 qemu_progress_end();
2112 qemu_opts_del(opts);
2113 qemu_opts_free(create_opts);
2114 qemu_opts_del(sn_opts);
2115 blk_unref(out_blk);
2116 g_free(bs);
2117 if (blk) {
2118 for (bs_i = 0; bs_i < bs_n; bs_i++) {
2119 blk_unref(blk[bs_i]);
2121 g_free(blk);
2123 g_free(bs_sectors);
2124 fail_getopt:
2125 g_free(options);
2127 if (ret) {
2128 return 1;
2130 return 0;
2134 static void dump_snapshots(BlockDriverState *bs)
2136 QEMUSnapshotInfo *sn_tab, *sn;
2137 int nb_sns, i;
2139 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
2140 if (nb_sns <= 0)
2141 return;
2142 printf("Snapshot list:\n");
2143 bdrv_snapshot_dump(fprintf, stdout, NULL);
2144 printf("\n");
2145 for(i = 0; i < nb_sns; i++) {
2146 sn = &sn_tab[i];
2147 bdrv_snapshot_dump(fprintf, stdout, sn);
2148 printf("\n");
2150 g_free(sn_tab);
2153 static void dump_json_image_info_list(ImageInfoList *list)
2155 Error *local_err = NULL;
2156 QString *str;
2157 QmpOutputVisitor *ov = qmp_output_visitor_new();
2158 QObject *obj;
2159 visit_type_ImageInfoList(qmp_output_get_visitor(ov), NULL, &list,
2160 &local_err);
2161 obj = qmp_output_get_qobject(ov);
2162 str = qobject_to_json_pretty(obj);
2163 assert(str != NULL);
2164 printf("%s\n", qstring_get_str(str));
2165 qobject_decref(obj);
2166 qmp_output_visitor_cleanup(ov);
2167 QDECREF(str);
2170 static void dump_json_image_info(ImageInfo *info)
2172 Error *local_err = NULL;
2173 QString *str;
2174 QmpOutputVisitor *ov = qmp_output_visitor_new();
2175 QObject *obj;
2176 visit_type_ImageInfo(qmp_output_get_visitor(ov), NULL, &info, &local_err);
2177 obj = qmp_output_get_qobject(ov);
2178 str = qobject_to_json_pretty(obj);
2179 assert(str != NULL);
2180 printf("%s\n", qstring_get_str(str));
2181 qobject_decref(obj);
2182 qmp_output_visitor_cleanup(ov);
2183 QDECREF(str);
2186 static void dump_human_image_info_list(ImageInfoList *list)
2188 ImageInfoList *elem;
2189 bool delim = false;
2191 for (elem = list; elem; elem = elem->next) {
2192 if (delim) {
2193 printf("\n");
2195 delim = true;
2197 bdrv_image_info_dump(fprintf, stdout, elem->value);
2201 static gboolean str_equal_func(gconstpointer a, gconstpointer b)
2203 return strcmp(a, b) == 0;
2207 * Open an image file chain and return an ImageInfoList
2209 * @filename: topmost image filename
2210 * @fmt: topmost image format (may be NULL to autodetect)
2211 * @chain: true - enumerate entire backing file chain
2212 * false - only topmost image file
2214 * Returns a list of ImageInfo objects or NULL if there was an error opening an
2215 * image file. If there was an error a message will have been printed to
2216 * stderr.
2218 static ImageInfoList *collect_image_info_list(bool image_opts,
2219 const char *filename,
2220 const char *fmt,
2221 bool chain)
2223 ImageInfoList *head = NULL;
2224 ImageInfoList **last = &head;
2225 GHashTable *filenames;
2226 Error *err = NULL;
2228 filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL);
2230 while (filename) {
2231 BlockBackend *blk;
2232 BlockDriverState *bs;
2233 ImageInfo *info;
2234 ImageInfoList *elem;
2236 if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) {
2237 error_report("Backing file '%s' creates an infinite loop.",
2238 filename);
2239 goto err;
2241 g_hash_table_insert(filenames, (gpointer)filename, NULL);
2243 blk = img_open("image", image_opts, filename, fmt,
2244 BDRV_O_FLAGS | BDRV_O_NO_BACKING,
2245 false, false);
2246 if (!blk) {
2247 goto err;
2249 bs = blk_bs(blk);
2251 bdrv_query_image_info(bs, &info, &err);
2252 if (err) {
2253 error_report_err(err);
2254 blk_unref(blk);
2255 goto err;
2258 elem = g_new0(ImageInfoList, 1);
2259 elem->value = info;
2260 *last = elem;
2261 last = &elem->next;
2263 blk_unref(blk);
2265 filename = fmt = NULL;
2266 if (chain) {
2267 if (info->has_full_backing_filename) {
2268 filename = info->full_backing_filename;
2269 } else if (info->has_backing_filename) {
2270 error_report("Could not determine absolute backing filename,"
2271 " but backing filename '%s' present",
2272 info->backing_filename);
2273 goto err;
2275 if (info->has_backing_filename_format) {
2276 fmt = info->backing_filename_format;
2280 g_hash_table_destroy(filenames);
2281 return head;
2283 err:
2284 qapi_free_ImageInfoList(head);
2285 g_hash_table_destroy(filenames);
2286 return NULL;
2289 static int img_info(int argc, char **argv)
2291 int c;
2292 OutputFormat output_format = OFORMAT_HUMAN;
2293 bool chain = false;
2294 const char *filename, *fmt, *output;
2295 ImageInfoList *list;
2296 Error *local_err = NULL;
2297 bool image_opts = false;
2299 fmt = NULL;
2300 output = NULL;
2301 for(;;) {
2302 int option_index = 0;
2303 static const struct option long_options[] = {
2304 {"help", no_argument, 0, 'h'},
2305 {"format", required_argument, 0, 'f'},
2306 {"output", required_argument, 0, OPTION_OUTPUT},
2307 {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN},
2308 {"object", required_argument, 0, OPTION_OBJECT},
2309 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
2310 {0, 0, 0, 0}
2312 c = getopt_long(argc, argv, "f:h",
2313 long_options, &option_index);
2314 if (c == -1) {
2315 break;
2317 switch(c) {
2318 case '?':
2319 case 'h':
2320 help();
2321 break;
2322 case 'f':
2323 fmt = optarg;
2324 break;
2325 case OPTION_OUTPUT:
2326 output = optarg;
2327 break;
2328 case OPTION_BACKING_CHAIN:
2329 chain = true;
2330 break;
2331 case OPTION_OBJECT: {
2332 QemuOpts *opts;
2333 opts = qemu_opts_parse_noisily(&qemu_object_opts,
2334 optarg, true);
2335 if (!opts) {
2336 return 1;
2338 } break;
2339 case OPTION_IMAGE_OPTS:
2340 image_opts = true;
2341 break;
2344 if (optind != argc - 1) {
2345 error_exit("Expecting one image file name");
2347 filename = argv[optind++];
2349 if (output && !strcmp(output, "json")) {
2350 output_format = OFORMAT_JSON;
2351 } else if (output && !strcmp(output, "human")) {
2352 output_format = OFORMAT_HUMAN;
2353 } else if (output) {
2354 error_report("--output must be used with human or json as argument.");
2355 return 1;
2358 if (qemu_opts_foreach(&qemu_object_opts,
2359 user_creatable_add_opts_foreach,
2360 NULL, &local_err)) {
2361 error_report_err(local_err);
2362 return 1;
2365 list = collect_image_info_list(image_opts, filename, fmt, chain);
2366 if (!list) {
2367 return 1;
2370 switch (output_format) {
2371 case OFORMAT_HUMAN:
2372 dump_human_image_info_list(list);
2373 break;
2374 case OFORMAT_JSON:
2375 if (chain) {
2376 dump_json_image_info_list(list);
2377 } else {
2378 dump_json_image_info(list->value);
2380 break;
2383 qapi_free_ImageInfoList(list);
2384 return 0;
2387 static void dump_map_entry(OutputFormat output_format, MapEntry *e,
2388 MapEntry *next)
2390 switch (output_format) {
2391 case OFORMAT_HUMAN:
2392 if (e->data && !e->has_offset) {
2393 error_report("File contains external, encrypted or compressed clusters.");
2394 exit(1);
2396 if (e->data && !e->zero) {
2397 printf("%#-16"PRIx64"%#-16"PRIx64"%#-16"PRIx64"%s\n",
2398 e->start, e->length,
2399 e->has_offset ? e->offset : 0,
2400 e->has_filename ? e->filename : "");
2402 /* This format ignores the distinction between 0, ZERO and ZERO|DATA.
2403 * Modify the flags here to allow more coalescing.
2405 if (next && (!next->data || next->zero)) {
2406 next->data = false;
2407 next->zero = true;
2409 break;
2410 case OFORMAT_JSON:
2411 printf("%s{ \"start\": %"PRId64", \"length\": %"PRId64","
2412 " \"depth\": %"PRId64", \"zero\": %s, \"data\": %s",
2413 (e->start == 0 ? "[" : ",\n"),
2414 e->start, e->length, e->depth,
2415 e->zero ? "true" : "false",
2416 e->data ? "true" : "false");
2417 if (e->has_offset) {
2418 printf(", \"offset\": %"PRId64"", e->offset);
2420 putchar('}');
2422 if (!next) {
2423 printf("]\n");
2425 break;
2429 static int get_block_status(BlockDriverState *bs, int64_t sector_num,
2430 int nb_sectors, MapEntry *e)
2432 int64_t ret;
2433 int depth;
2434 BlockDriverState *file;
2435 bool has_offset;
2437 /* As an optimization, we could cache the current range of unallocated
2438 * clusters in each file of the chain, and avoid querying the same
2439 * range repeatedly.
2442 depth = 0;
2443 for (;;) {
2444 ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &nb_sectors,
2445 &file);
2446 if (ret < 0) {
2447 return ret;
2449 assert(nb_sectors);
2450 if (ret & (BDRV_BLOCK_ZERO|BDRV_BLOCK_DATA)) {
2451 break;
2453 bs = backing_bs(bs);
2454 if (bs == NULL) {
2455 ret = 0;
2456 break;
2459 depth++;
2462 has_offset = !!(ret & BDRV_BLOCK_OFFSET_VALID);
2464 *e = (MapEntry) {
2465 .start = sector_num * BDRV_SECTOR_SIZE,
2466 .length = nb_sectors * BDRV_SECTOR_SIZE,
2467 .data = !!(ret & BDRV_BLOCK_DATA),
2468 .zero = !!(ret & BDRV_BLOCK_ZERO),
2469 .offset = ret & BDRV_BLOCK_OFFSET_MASK,
2470 .has_offset = has_offset,
2471 .depth = depth,
2472 .has_filename = file && has_offset,
2473 .filename = file && has_offset ? file->filename : NULL,
2476 return 0;
2479 static inline bool entry_mergeable(const MapEntry *curr, const MapEntry *next)
2481 if (curr->length == 0) {
2482 return false;
2484 if (curr->zero != next->zero ||
2485 curr->data != next->data ||
2486 curr->depth != next->depth ||
2487 curr->has_filename != next->has_filename ||
2488 curr->has_offset != next->has_offset) {
2489 return false;
2491 if (curr->has_filename && strcmp(curr->filename, next->filename)) {
2492 return false;
2494 if (curr->has_offset && curr->offset + curr->length != next->offset) {
2495 return false;
2497 return true;
2500 static int img_map(int argc, char **argv)
2502 int c;
2503 OutputFormat output_format = OFORMAT_HUMAN;
2504 BlockBackend *blk;
2505 BlockDriverState *bs;
2506 const char *filename, *fmt, *output;
2507 int64_t length;
2508 MapEntry curr = { .length = 0 }, next;
2509 int ret = 0;
2510 Error *local_err = NULL;
2511 bool image_opts = false;
2513 fmt = NULL;
2514 output = NULL;
2515 for (;;) {
2516 int option_index = 0;
2517 static const struct option long_options[] = {
2518 {"help", no_argument, 0, 'h'},
2519 {"format", required_argument, 0, 'f'},
2520 {"output", required_argument, 0, OPTION_OUTPUT},
2521 {"object", required_argument, 0, OPTION_OBJECT},
2522 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
2523 {0, 0, 0, 0}
2525 c = getopt_long(argc, argv, "f:h",
2526 long_options, &option_index);
2527 if (c == -1) {
2528 break;
2530 switch (c) {
2531 case '?':
2532 case 'h':
2533 help();
2534 break;
2535 case 'f':
2536 fmt = optarg;
2537 break;
2538 case OPTION_OUTPUT:
2539 output = optarg;
2540 break;
2541 case OPTION_OBJECT: {
2542 QemuOpts *opts;
2543 opts = qemu_opts_parse_noisily(&qemu_object_opts,
2544 optarg, true);
2545 if (!opts) {
2546 return 1;
2548 } break;
2549 case OPTION_IMAGE_OPTS:
2550 image_opts = true;
2551 break;
2554 if (optind != argc - 1) {
2555 error_exit("Expecting one image file name");
2557 filename = argv[optind];
2559 if (output && !strcmp(output, "json")) {
2560 output_format = OFORMAT_JSON;
2561 } else if (output && !strcmp(output, "human")) {
2562 output_format = OFORMAT_HUMAN;
2563 } else if (output) {
2564 error_report("--output must be used with human or json as argument.");
2565 return 1;
2568 if (qemu_opts_foreach(&qemu_object_opts,
2569 user_creatable_add_opts_foreach,
2570 NULL, &local_err)) {
2571 error_report_err(local_err);
2572 return 1;
2575 blk = img_open("image", image_opts, filename, fmt,
2576 BDRV_O_FLAGS, true, false);
2577 if (!blk) {
2578 return 1;
2580 bs = blk_bs(blk);
2582 if (output_format == OFORMAT_HUMAN) {
2583 printf("%-16s%-16s%-16s%s\n", "Offset", "Length", "Mapped to", "File");
2586 length = blk_getlength(blk);
2587 while (curr.start + curr.length < length) {
2588 int64_t nsectors_left;
2589 int64_t sector_num;
2590 int n;
2592 sector_num = (curr.start + curr.length) >> BDRV_SECTOR_BITS;
2594 /* Probe up to 1 GiB at a time. */
2595 nsectors_left = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE) - sector_num;
2596 n = MIN(1 << (30 - BDRV_SECTOR_BITS), nsectors_left);
2597 ret = get_block_status(bs, sector_num, n, &next);
2599 if (ret < 0) {
2600 error_report("Could not read file metadata: %s", strerror(-ret));
2601 goto out;
2604 if (entry_mergeable(&curr, &next)) {
2605 curr.length += next.length;
2606 continue;
2609 if (curr.length > 0) {
2610 dump_map_entry(output_format, &curr, &next);
2612 curr = next;
2615 dump_map_entry(output_format, &curr, NULL);
2617 out:
2618 blk_unref(blk);
2619 return ret < 0;
2622 #define SNAPSHOT_LIST 1
2623 #define SNAPSHOT_CREATE 2
2624 #define SNAPSHOT_APPLY 3
2625 #define SNAPSHOT_DELETE 4
2627 static int img_snapshot(int argc, char **argv)
2629 BlockBackend *blk;
2630 BlockDriverState *bs;
2631 QEMUSnapshotInfo sn;
2632 char *filename, *snapshot_name = NULL;
2633 int c, ret = 0, bdrv_oflags;
2634 int action = 0;
2635 qemu_timeval tv;
2636 bool quiet = false;
2637 Error *err = NULL;
2638 bool image_opts = false;
2640 bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
2641 /* Parse commandline parameters */
2642 for(;;) {
2643 static const struct option long_options[] = {
2644 {"help", no_argument, 0, 'h'},
2645 {"object", required_argument, 0, OPTION_OBJECT},
2646 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
2647 {0, 0, 0, 0}
2649 c = getopt_long(argc, argv, "la:c:d:hq",
2650 long_options, NULL);
2651 if (c == -1) {
2652 break;
2654 switch(c) {
2655 case '?':
2656 case 'h':
2657 help();
2658 return 0;
2659 case 'l':
2660 if (action) {
2661 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2662 return 0;
2664 action = SNAPSHOT_LIST;
2665 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
2666 break;
2667 case 'a':
2668 if (action) {
2669 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2670 return 0;
2672 action = SNAPSHOT_APPLY;
2673 snapshot_name = optarg;
2674 break;
2675 case 'c':
2676 if (action) {
2677 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2678 return 0;
2680 action = SNAPSHOT_CREATE;
2681 snapshot_name = optarg;
2682 break;
2683 case 'd':
2684 if (action) {
2685 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2686 return 0;
2688 action = SNAPSHOT_DELETE;
2689 snapshot_name = optarg;
2690 break;
2691 case 'q':
2692 quiet = true;
2693 break;
2694 case OPTION_OBJECT: {
2695 QemuOpts *opts;
2696 opts = qemu_opts_parse_noisily(&qemu_object_opts,
2697 optarg, true);
2698 if (!opts) {
2699 return 1;
2701 } break;
2702 case OPTION_IMAGE_OPTS:
2703 image_opts = true;
2704 break;
2708 if (optind != argc - 1) {
2709 error_exit("Expecting one image file name");
2711 filename = argv[optind++];
2713 if (qemu_opts_foreach(&qemu_object_opts,
2714 user_creatable_add_opts_foreach,
2715 NULL, &err)) {
2716 error_report_err(err);
2717 return 1;
2720 /* Open the image */
2721 blk = img_open("image", image_opts, filename, NULL,
2722 bdrv_oflags, true, quiet);
2723 if (!blk) {
2724 return 1;
2726 bs = blk_bs(blk);
2728 /* Perform the requested action */
2729 switch(action) {
2730 case SNAPSHOT_LIST:
2731 dump_snapshots(bs);
2732 break;
2734 case SNAPSHOT_CREATE:
2735 memset(&sn, 0, sizeof(sn));
2736 pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
2738 qemu_gettimeofday(&tv);
2739 sn.date_sec = tv.tv_sec;
2740 sn.date_nsec = tv.tv_usec * 1000;
2742 ret = bdrv_snapshot_create(bs, &sn);
2743 if (ret) {
2744 error_report("Could not create snapshot '%s': %d (%s)",
2745 snapshot_name, ret, strerror(-ret));
2747 break;
2749 case SNAPSHOT_APPLY:
2750 ret = bdrv_snapshot_goto(bs, snapshot_name);
2751 if (ret) {
2752 error_report("Could not apply snapshot '%s': %d (%s)",
2753 snapshot_name, ret, strerror(-ret));
2755 break;
2757 case SNAPSHOT_DELETE:
2758 bdrv_snapshot_delete_by_id_or_name(bs, snapshot_name, &err);
2759 if (err) {
2760 error_reportf_err(err, "Could not delete snapshot '%s': ",
2761 snapshot_name);
2762 ret = 1;
2764 break;
2767 /* Cleanup */
2768 blk_unref(blk);
2769 if (ret) {
2770 return 1;
2772 return 0;
2775 static int img_rebase(int argc, char **argv)
2777 BlockBackend *blk = NULL, *blk_old_backing = NULL, *blk_new_backing = NULL;
2778 BlockDriverState *bs = NULL;
2779 char *filename;
2780 const char *fmt, *cache, *src_cache, *out_basefmt, *out_baseimg;
2781 int c, flags, src_flags, ret;
2782 int unsafe = 0;
2783 int progress = 0;
2784 bool quiet = false;
2785 Error *local_err = NULL;
2786 bool image_opts = false;
2788 /* Parse commandline parameters */
2789 fmt = NULL;
2790 cache = BDRV_DEFAULT_CACHE;
2791 src_cache = BDRV_DEFAULT_CACHE;
2792 out_baseimg = NULL;
2793 out_basefmt = NULL;
2794 for(;;) {
2795 static const struct option long_options[] = {
2796 {"help", no_argument, 0, 'h'},
2797 {"object", required_argument, 0, OPTION_OBJECT},
2798 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
2799 {0, 0, 0, 0}
2801 c = getopt_long(argc, argv, "hf:F:b:upt:T:q",
2802 long_options, NULL);
2803 if (c == -1) {
2804 break;
2806 switch(c) {
2807 case '?':
2808 case 'h':
2809 help();
2810 return 0;
2811 case 'f':
2812 fmt = optarg;
2813 break;
2814 case 'F':
2815 out_basefmt = optarg;
2816 break;
2817 case 'b':
2818 out_baseimg = optarg;
2819 break;
2820 case 'u':
2821 unsafe = 1;
2822 break;
2823 case 'p':
2824 progress = 1;
2825 break;
2826 case 't':
2827 cache = optarg;
2828 break;
2829 case 'T':
2830 src_cache = optarg;
2831 break;
2832 case 'q':
2833 quiet = true;
2834 break;
2835 case OPTION_OBJECT: {
2836 QemuOpts *opts;
2837 opts = qemu_opts_parse_noisily(&qemu_object_opts,
2838 optarg, true);
2839 if (!opts) {
2840 return 1;
2842 } break;
2843 case OPTION_IMAGE_OPTS:
2844 image_opts = true;
2845 break;
2849 if (quiet) {
2850 progress = 0;
2853 if (optind != argc - 1) {
2854 error_exit("Expecting one image file name");
2856 if (!unsafe && !out_baseimg) {
2857 error_exit("Must specify backing file (-b) or use unsafe mode (-u)");
2859 filename = argv[optind++];
2861 if (qemu_opts_foreach(&qemu_object_opts,
2862 user_creatable_add_opts_foreach,
2863 NULL, &local_err)) {
2864 error_report_err(local_err);
2865 return 1;
2868 qemu_progress_init(progress, 2.0);
2869 qemu_progress_print(0, 100);
2871 flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
2872 ret = bdrv_parse_cache_flags(cache, &flags);
2873 if (ret < 0) {
2874 error_report("Invalid cache option: %s", cache);
2875 goto out;
2878 src_flags = BDRV_O_FLAGS;
2879 ret = bdrv_parse_cache_flags(src_cache, &src_flags);
2880 if (ret < 0) {
2881 error_report("Invalid source cache option: %s", src_cache);
2882 goto out;
2886 * Open the images.
2888 * Ignore the old backing file for unsafe rebase in case we want to correct
2889 * the reference to a renamed or moved backing file.
2891 blk = img_open("image", image_opts, filename, fmt, flags, true, quiet);
2892 if (!blk) {
2893 ret = -1;
2894 goto out;
2896 bs = blk_bs(blk);
2898 if (out_basefmt != NULL) {
2899 if (bdrv_find_format(out_basefmt) == NULL) {
2900 error_report("Invalid format name: '%s'", out_basefmt);
2901 ret = -1;
2902 goto out;
2906 /* For safe rebasing we need to compare old and new backing file */
2907 if (!unsafe) {
2908 char backing_name[PATH_MAX];
2909 QDict *options = NULL;
2911 if (bs->backing_format[0] != '\0') {
2912 options = qdict_new();
2913 qdict_put(options, "driver", qstring_from_str(bs->backing_format));
2916 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
2917 blk_old_backing = blk_new_open("old_backing", backing_name, NULL,
2918 options, src_flags, &local_err);
2919 if (!blk_old_backing) {
2920 error_reportf_err(local_err,
2921 "Could not open old backing file '%s': ",
2922 backing_name);
2923 goto out;
2926 if (out_baseimg[0]) {
2927 if (out_basefmt) {
2928 options = qdict_new();
2929 qdict_put(options, "driver", qstring_from_str(out_basefmt));
2930 } else {
2931 options = NULL;
2934 blk_new_backing = blk_new_open("new_backing", out_baseimg, NULL,
2935 options, src_flags, &local_err);
2936 if (!blk_new_backing) {
2937 error_reportf_err(local_err,
2938 "Could not open new backing file '%s': ",
2939 out_baseimg);
2940 goto out;
2946 * Check each unallocated cluster in the COW file. If it is unallocated,
2947 * accesses go to the backing file. We must therefore compare this cluster
2948 * in the old and new backing file, and if they differ we need to copy it
2949 * from the old backing file into the COW file.
2951 * If qemu-img crashes during this step, no harm is done. The content of
2952 * the image is the same as the original one at any time.
2954 if (!unsafe) {
2955 int64_t num_sectors;
2956 int64_t old_backing_num_sectors;
2957 int64_t new_backing_num_sectors = 0;
2958 uint64_t sector;
2959 int n;
2960 uint8_t * buf_old;
2961 uint8_t * buf_new;
2962 float local_progress = 0;
2964 buf_old = blk_blockalign(blk, IO_BUF_SIZE);
2965 buf_new = blk_blockalign(blk, IO_BUF_SIZE);
2967 num_sectors = blk_nb_sectors(blk);
2968 if (num_sectors < 0) {
2969 error_report("Could not get size of '%s': %s",
2970 filename, strerror(-num_sectors));
2971 ret = -1;
2972 goto out;
2974 old_backing_num_sectors = blk_nb_sectors(blk_old_backing);
2975 if (old_backing_num_sectors < 0) {
2976 char backing_name[PATH_MAX];
2978 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
2979 error_report("Could not get size of '%s': %s",
2980 backing_name, strerror(-old_backing_num_sectors));
2981 ret = -1;
2982 goto out;
2984 if (blk_new_backing) {
2985 new_backing_num_sectors = blk_nb_sectors(blk_new_backing);
2986 if (new_backing_num_sectors < 0) {
2987 error_report("Could not get size of '%s': %s",
2988 out_baseimg, strerror(-new_backing_num_sectors));
2989 ret = -1;
2990 goto out;
2994 if (num_sectors != 0) {
2995 local_progress = (float)100 /
2996 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
2999 for (sector = 0; sector < num_sectors; sector += n) {
3001 /* How many sectors can we handle with the next read? */
3002 if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
3003 n = (IO_BUF_SIZE / 512);
3004 } else {
3005 n = num_sectors - sector;
3008 /* If the cluster is allocated, we don't need to take action */
3009 ret = bdrv_is_allocated(bs, sector, n, &n);
3010 if (ret < 0) {
3011 error_report("error while reading image metadata: %s",
3012 strerror(-ret));
3013 goto out;
3015 if (ret) {
3016 continue;
3020 * Read old and new backing file and take into consideration that
3021 * backing files may be smaller than the COW image.
3023 if (sector >= old_backing_num_sectors) {
3024 memset(buf_old, 0, n * BDRV_SECTOR_SIZE);
3025 } else {
3026 if (sector + n > old_backing_num_sectors) {
3027 n = old_backing_num_sectors - sector;
3030 ret = blk_read(blk_old_backing, sector, buf_old, n);
3031 if (ret < 0) {
3032 error_report("error while reading from old backing file");
3033 goto out;
3037 if (sector >= new_backing_num_sectors || !blk_new_backing) {
3038 memset(buf_new, 0, n * BDRV_SECTOR_SIZE);
3039 } else {
3040 if (sector + n > new_backing_num_sectors) {
3041 n = new_backing_num_sectors - sector;
3044 ret = blk_read(blk_new_backing, sector, buf_new, n);
3045 if (ret < 0) {
3046 error_report("error while reading from new backing file");
3047 goto out;
3051 /* If they differ, we need to write to the COW file */
3052 uint64_t written = 0;
3054 while (written < n) {
3055 int pnum;
3057 if (compare_sectors(buf_old + written * 512,
3058 buf_new + written * 512, n - written, &pnum))
3060 ret = blk_write(blk, sector + written,
3061 buf_old + written * 512, pnum);
3062 if (ret < 0) {
3063 error_report("Error while writing to COW image: %s",
3064 strerror(-ret));
3065 goto out;
3069 written += pnum;
3071 qemu_progress_print(local_progress, 100);
3074 qemu_vfree(buf_old);
3075 qemu_vfree(buf_new);
3079 * Change the backing file. All clusters that are different from the old
3080 * backing file are overwritten in the COW file now, so the visible content
3081 * doesn't change when we switch the backing file.
3083 if (out_baseimg && *out_baseimg) {
3084 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
3085 } else {
3086 ret = bdrv_change_backing_file(bs, NULL, NULL);
3089 if (ret == -ENOSPC) {
3090 error_report("Could not change the backing file to '%s': No "
3091 "space left in the file header", out_baseimg);
3092 } else if (ret < 0) {
3093 error_report("Could not change the backing file to '%s': %s",
3094 out_baseimg, strerror(-ret));
3097 qemu_progress_print(100, 0);
3099 * TODO At this point it is possible to check if any clusters that are
3100 * allocated in the COW file are the same in the backing file. If so, they
3101 * could be dropped from the COW file. Don't do this before switching the
3102 * backing file, in case of a crash this would lead to corruption.
3104 out:
3105 qemu_progress_end();
3106 /* Cleanup */
3107 if (!unsafe) {
3108 blk_unref(blk_old_backing);
3109 blk_unref(blk_new_backing);
3112 blk_unref(blk);
3113 if (ret) {
3114 return 1;
3116 return 0;
3119 static int img_resize(int argc, char **argv)
3121 Error *err = NULL;
3122 int c, ret, relative;
3123 const char *filename, *fmt, *size;
3124 int64_t n, total_size;
3125 bool quiet = false;
3126 BlockBackend *blk = NULL;
3127 QemuOpts *param;
3128 Error *local_err = NULL;
3130 static QemuOptsList resize_options = {
3131 .name = "resize_options",
3132 .head = QTAILQ_HEAD_INITIALIZER(resize_options.head),
3133 .desc = {
3135 .name = BLOCK_OPT_SIZE,
3136 .type = QEMU_OPT_SIZE,
3137 .help = "Virtual disk size"
3138 }, {
3139 /* end of list */
3143 bool image_opts = false;
3145 /* Remove size from argv manually so that negative numbers are not treated
3146 * as options by getopt. */
3147 if (argc < 3) {
3148 error_exit("Not enough arguments");
3149 return 1;
3152 size = argv[--argc];
3154 /* Parse getopt arguments */
3155 fmt = NULL;
3156 for(;;) {
3157 static const struct option long_options[] = {
3158 {"help", no_argument, 0, 'h'},
3159 {"object", required_argument, 0, OPTION_OBJECT},
3160 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
3161 {0, 0, 0, 0}
3163 c = getopt_long(argc, argv, "f:hq",
3164 long_options, NULL);
3165 if (c == -1) {
3166 break;
3168 switch(c) {
3169 case '?':
3170 case 'h':
3171 help();
3172 break;
3173 case 'f':
3174 fmt = optarg;
3175 break;
3176 case 'q':
3177 quiet = true;
3178 break;
3179 case OPTION_OBJECT: {
3180 QemuOpts *opts;
3181 opts = qemu_opts_parse_noisily(&qemu_object_opts,
3182 optarg, true);
3183 if (!opts) {
3184 return 1;
3186 } break;
3187 case OPTION_IMAGE_OPTS:
3188 image_opts = true;
3189 break;
3192 if (optind != argc - 1) {
3193 error_exit("Expecting one image file name");
3195 filename = argv[optind++];
3197 if (qemu_opts_foreach(&qemu_object_opts,
3198 user_creatable_add_opts_foreach,
3199 NULL, &local_err)) {
3200 error_report_err(local_err);
3201 return 1;
3204 /* Choose grow, shrink, or absolute resize mode */
3205 switch (size[0]) {
3206 case '+':
3207 relative = 1;
3208 size++;
3209 break;
3210 case '-':
3211 relative = -1;
3212 size++;
3213 break;
3214 default:
3215 relative = 0;
3216 break;
3219 /* Parse size */
3220 param = qemu_opts_create(&resize_options, NULL, 0, &error_abort);
3221 qemu_opt_set(param, BLOCK_OPT_SIZE, size, &err);
3222 if (err) {
3223 error_report_err(err);
3224 ret = -1;
3225 qemu_opts_del(param);
3226 goto out;
3228 n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
3229 qemu_opts_del(param);
3231 blk = img_open("image", image_opts, filename, fmt,
3232 BDRV_O_FLAGS | BDRV_O_RDWR, true, quiet);
3233 if (!blk) {
3234 ret = -1;
3235 goto out;
3238 if (relative) {
3239 total_size = blk_getlength(blk) + n * relative;
3240 } else {
3241 total_size = n;
3243 if (total_size <= 0) {
3244 error_report("New image size must be positive");
3245 ret = -1;
3246 goto out;
3249 ret = blk_truncate(blk, total_size);
3250 switch (ret) {
3251 case 0:
3252 qprintf(quiet, "Image resized.\n");
3253 break;
3254 case -ENOTSUP:
3255 error_report("This image does not support resize");
3256 break;
3257 case -EACCES:
3258 error_report("Image is read-only");
3259 break;
3260 default:
3261 error_report("Error resizing image (%d)", -ret);
3262 break;
3264 out:
3265 blk_unref(blk);
3266 if (ret) {
3267 return 1;
3269 return 0;
3272 static void amend_status_cb(BlockDriverState *bs,
3273 int64_t offset, int64_t total_work_size,
3274 void *opaque)
3276 qemu_progress_print(100.f * offset / total_work_size, 0);
3279 static int img_amend(int argc, char **argv)
3281 Error *err = NULL;
3282 int c, ret = 0;
3283 char *options = NULL;
3284 QemuOptsList *create_opts = NULL;
3285 QemuOpts *opts = NULL;
3286 const char *fmt = NULL, *filename, *cache;
3287 int flags;
3288 bool quiet = false, progress = false;
3289 BlockBackend *blk = NULL;
3290 BlockDriverState *bs = NULL;
3291 Error *local_err = NULL;
3292 bool image_opts = false;
3294 cache = BDRV_DEFAULT_CACHE;
3295 for (;;) {
3296 static const struct option long_options[] = {
3297 {"help", no_argument, 0, 'h'},
3298 {"object", required_argument, 0, OPTION_OBJECT},
3299 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
3300 {0, 0, 0, 0}
3302 c = getopt_long(argc, argv, "ho:f:t:pq",
3303 long_options, NULL);
3304 if (c == -1) {
3305 break;
3308 switch (c) {
3309 case 'h':
3310 case '?':
3311 help();
3312 break;
3313 case 'o':
3314 if (!is_valid_option_list(optarg)) {
3315 error_report("Invalid option list: %s", optarg);
3316 ret = -1;
3317 goto out_no_progress;
3319 if (!options) {
3320 options = g_strdup(optarg);
3321 } else {
3322 char *old_options = options;
3323 options = g_strdup_printf("%s,%s", options, optarg);
3324 g_free(old_options);
3326 break;
3327 case 'f':
3328 fmt = optarg;
3329 break;
3330 case 't':
3331 cache = optarg;
3332 break;
3333 case 'p':
3334 progress = true;
3335 break;
3336 case 'q':
3337 quiet = true;
3338 break;
3339 case OPTION_OBJECT:
3340 opts = qemu_opts_parse_noisily(&qemu_object_opts,
3341 optarg, true);
3342 if (!opts) {
3343 ret = -1;
3344 goto out_no_progress;
3346 break;
3347 case OPTION_IMAGE_OPTS:
3348 image_opts = true;
3349 break;
3353 if (!options) {
3354 error_exit("Must specify options (-o)");
3357 if (qemu_opts_foreach(&qemu_object_opts,
3358 user_creatable_add_opts_foreach,
3359 NULL, &local_err)) {
3360 error_report_err(local_err);
3361 ret = -1;
3362 goto out_no_progress;
3365 if (quiet) {
3366 progress = false;
3368 qemu_progress_init(progress, 1.0);
3370 filename = (optind == argc - 1) ? argv[argc - 1] : NULL;
3371 if (fmt && has_help_option(options)) {
3372 /* If a format is explicitly specified (and possibly no filename is
3373 * given), print option help here */
3374 ret = print_block_option_help(filename, fmt);
3375 goto out;
3378 if (optind != argc - 1) {
3379 error_report("Expecting one image file name");
3380 ret = -1;
3381 goto out;
3384 flags = BDRV_O_FLAGS | BDRV_O_RDWR;
3385 ret = bdrv_parse_cache_flags(cache, &flags);
3386 if (ret < 0) {
3387 error_report("Invalid cache option: %s", cache);
3388 goto out;
3391 blk = img_open("image", image_opts, filename, fmt, flags, true, quiet);
3392 if (!blk) {
3393 ret = -1;
3394 goto out;
3396 bs = blk_bs(blk);
3398 fmt = bs->drv->format_name;
3400 if (has_help_option(options)) {
3401 /* If the format was auto-detected, print option help here */
3402 ret = print_block_option_help(filename, fmt);
3403 goto out;
3406 if (!bs->drv->create_opts) {
3407 error_report("Format driver '%s' does not support any options to amend",
3408 fmt);
3409 ret = -1;
3410 goto out;
3413 create_opts = qemu_opts_append(create_opts, bs->drv->create_opts);
3414 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
3415 if (options) {
3416 qemu_opts_do_parse(opts, options, NULL, &err);
3417 if (err) {
3418 error_report_err(err);
3419 ret = -1;
3420 goto out;
3424 /* In case the driver does not call amend_status_cb() */
3425 qemu_progress_print(0.f, 0);
3426 ret = bdrv_amend_options(bs, opts, &amend_status_cb, NULL);
3427 qemu_progress_print(100.f, 0);
3428 if (ret < 0) {
3429 error_report("Error while amending options: %s", strerror(-ret));
3430 goto out;
3433 out:
3434 qemu_progress_end();
3436 out_no_progress:
3437 blk_unref(blk);
3438 qemu_opts_del(opts);
3439 qemu_opts_free(create_opts);
3440 g_free(options);
3442 if (ret) {
3443 return 1;
3445 return 0;
3448 static const img_cmd_t img_cmds[] = {
3449 #define DEF(option, callback, arg_string) \
3450 { option, callback },
3451 #include "qemu-img-cmds.h"
3452 #undef DEF
3453 #undef GEN_DOCS
3454 { NULL, NULL, },
3457 int main(int argc, char **argv)
3459 const img_cmd_t *cmd;
3460 const char *cmdname;
3461 Error *local_error = NULL;
3462 int c;
3463 static const struct option long_options[] = {
3464 {"help", no_argument, 0, 'h'},
3465 {"version", no_argument, 0, 'v'},
3466 {0, 0, 0, 0}
3469 #ifdef CONFIG_POSIX
3470 signal(SIGPIPE, SIG_IGN);
3471 #endif
3473 error_set_progname(argv[0]);
3474 qemu_init_exec_dir(argv[0]);
3476 if (qemu_init_main_loop(&local_error)) {
3477 error_report_err(local_error);
3478 exit(EXIT_FAILURE);
3481 module_call_init(MODULE_INIT_QOM);
3482 bdrv_init();
3483 if (argc < 2) {
3484 error_exit("Not enough arguments");
3486 cmdname = argv[1];
3488 qemu_add_opts(&qemu_object_opts);
3489 qemu_add_opts(&qemu_source_opts);
3491 /* find the command */
3492 for (cmd = img_cmds; cmd->name != NULL; cmd++) {
3493 if (!strcmp(cmdname, cmd->name)) {
3494 return cmd->handler(argc - 1, argv + 1);
3498 c = getopt_long(argc, argv, "h", long_options, NULL);
3500 if (c == 'h') {
3501 help();
3503 if (c == 'v') {
3504 printf(QEMU_IMG_VERSION);
3505 return 0;
3508 /* not found */
3509 error_exit("Command not found: %s", cmdname);