?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
OpenBIOS: switch over to official OpenBIOS git repo
[qemu/kevin.git] / qemu-img.c
blobea5970bdd3386cd78b4680594e21e0ed64ec230c
1 /*
2 * QEMU disk image utility
3 *
4 * Copyright (c) 2003-2008 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24 #include "qemu/osdep.h"
25 #include "qemu-version.h"
26 #include "qapi/error.h"
27 #include "qapi-visit.h"
28 #include "qapi/qmp-output-visitor.h"
29 #include "qapi/qmp/qerror.h"
30 #include "qapi/qmp/qjson.h"
31 #include "qemu/cutils.h"
32 #include "qemu/config-file.h"
33 #include "qemu/option.h"
34 #include "qemu/error-report.h"
35 #include "qemu/log.h"
36 #include "qom/object_interfaces.h"
37 #include "sysemu/sysemu.h"
38 #include "sysemu/block-backend.h"
39 #include "block/block_int.h"
40 #include "block/blockjob.h"
41 #include "block/qapi.h"
42 #include "crypto/init.h"
43 #include "trace/control.h"
44 #include <getopt.h>
45
46 #define QEMU_IMG_VERSION "qemu-img version " QEMU_VERSION QEMU_PKGVERSION \
47 ", Copyright (c) 2004-2008 Fabrice Bellard\n"
48
49 typedef struct img_cmd_t {
50 const char *name;
51 int (*handler)(int argc, char **argv);
52 } img_cmd_t;
53
54 enum {
55 OPTION_OUTPUT = 256,
56 OPTION_BACKING_CHAIN = 257,
57 OPTION_OBJECT = 258,
58 OPTION_IMAGE_OPTS = 259,
59 OPTION_PATTERN = 260,
60 OPTION_FLUSH_INTERVAL = 261,
61 OPTION_NO_DRAIN = 262,
62 };
63
64 typedef enum OutputFormat {
65 OFORMAT_JSON,
66 OFORMAT_HUMAN,
67 } OutputFormat;
68
69 /* Default to cache=writeback as data integrity is not important for qemu-img */
70 #define BDRV_DEFAULT_CACHE "writeback"
71
72 static void format_print(void *opaque, const char *name)
73 {
74 printf(" %s", name);
75 }
76
77 static void QEMU_NORETURN GCC_FMT_ATTR(1, 2) error_exit(const char *fmt, ...)
78 {
79 va_list ap;
80
81 error_printf("qemu-img: ");
82
83 va_start(ap, fmt);
84 error_vprintf(fmt, ap);
85 va_end(ap);
86
87 error_printf("\nTry 'qemu-img --help' for more information\n");
88 exit(EXIT_FAILURE);
89 }
90
91 /* Please keep in synch with qemu-img.texi */
92 static void QEMU_NORETURN help(void)
93 {
94 const char *help_msg =
95 QEMU_IMG_VERSION
96 "usage: qemu-img [standard options] command [command options]\n"
97 "QEMU disk image utility\n"
98 "\n"
99 " '-h', '--help' display this help and exit\n"
100 " '-V', '--version' output version information and exit\n"
101 " '-T', '--trace' [[enable=]<pattern>][,events=<file>][,file=<file>]\n"
102 " specify tracing options\n"
103 "\n"
104 "Command syntax:\n"
105 #define DEF(option, callback, arg_string) \
106 " " arg_string "\n"
107 #include "qemu-img-cmds.h"
108 #undef DEF
109 #undef GEN_DOCS
110 "\n"
111 "Command parameters:\n"
112 " 'filename' is a disk image filename\n"
113 " 'objectdef' is a QEMU user creatable object definition. See the qemu(1)\n"
114 " manual page for a description of the object properties. The most common\n"
115 " object type is a 'secret', which is used to supply passwords and/or\n"
116 " encryption keys.\n"
117 " 'fmt' is the disk image format. It is guessed automatically in most cases\n"
118 " 'cache' is the cache mode used to write the output disk image, the valid\n"
119 " options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n"
120 " 'directsync' and 'unsafe' (default for convert)\n"
121 " 'src_cache' is the cache mode used to read input disk images, the valid\n"
122 " options are the same as for the 'cache' option\n"
123 " 'size' is the disk image size in bytes. Optional suffixes\n"
124 " 'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M),\n"
125 " 'T' (terabyte, 1024G), 'P' (petabyte, 1024T) and 'E' (exabyte, 1024P) are\n"
126 " supported. 'b' is ignored.\n"
127 " 'output_filename' is the destination disk image filename\n"
128 " 'output_fmt' is the destination format\n"
129 " 'options' is a comma separated list of format specific options in a\n"
130 " name=value format. Use -o ? for an overview of the options supported by the\n"
131 " used format\n"
132 " 'snapshot_param' is param used for internal snapshot, format\n"
133 " is 'snapshot.id=[ID],snapshot.name=[NAME]', or\n"
134 " '[ID_OR_NAME]'\n"
135 " 'snapshot_id_or_name' is deprecated, use 'snapshot_param'\n"
136 " instead\n"
137 " '-c' indicates that target image must be compressed (qcow format only)\n"
138 " '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
139 " match exactly. The image doesn't need a working backing file before\n"
140 " rebasing in this case (useful for renaming the backing file)\n"
141 " '-h' with or without a command shows this help and lists the supported formats\n"
142 " '-p' show progress of command (only certain commands)\n"
143 " '-q' use Quiet mode - do not print any output (except errors)\n"
144 " '-S' indicates the consecutive number of bytes (defaults to 4k) that must\n"
145 " contain only zeros for qemu-img to create a sparse image during\n"
146 " conversion. If the number of bytes is 0, the source will not be scanned for\n"
147 " unallocated or zero sectors, and the destination image will always be\n"
148 " fully allocated\n"
149 " '--output' takes the format in which the output must be done (human or json)\n"
150 " '-n' skips the target volume creation (useful if the volume is created\n"
151 " prior to running qemu-img)\n"
152 "\n"
153 "Parameters to check subcommand:\n"
154 " '-r' tries to repair any inconsistencies that are found during the check.\n"
155 " '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n"
156 " kinds of errors, with a higher risk of choosing the wrong fix or\n"
157 " hiding corruption that has already occurred.\n"
158 "\n"
159 "Parameters to snapshot subcommand:\n"
160 " 'snapshot' is the name of the snapshot to create, apply or delete\n"
161 " '-a' applies a snapshot (revert disk to saved state)\n"
162 " '-c' creates a snapshot\n"
163 " '-d' deletes a snapshot\n"
164 " '-l' lists all snapshots in the given image\n"
165 "\n"
166 "Parameters to compare subcommand:\n"
167 " '-f' first image format\n"
168 " '-F' second image format\n"
169 " '-s' run in Strict mode - fail on different image size or sector allocation\n";
170
171 printf("%s\nSupported formats:", help_msg);
172 bdrv_iterate_format(format_print, NULL);
173 printf("\n");
174 exit(EXIT_SUCCESS);
175 }
176
177 static QemuOptsList qemu_object_opts = {
178 .name = "object",
179 .implied_opt_name = "qom-type",
180 .head = QTAILQ_HEAD_INITIALIZER(qemu_object_opts.head),
181 .desc = {
182 { }
183 },
184 };
185
186 static QemuOptsList qemu_source_opts = {
187 .name = "source",
188 .implied_opt_name = "file",
189 .head = QTAILQ_HEAD_INITIALIZER(qemu_source_opts.head),
190 .desc = {
191 { }
192 },
193 };
194
195 static int GCC_FMT_ATTR(2, 3) qprintf(bool quiet, const char *fmt, ...)
196 {
197 int ret = 0;
198 if (!quiet) {
199 va_list args;
200 va_start(args, fmt);
201 ret = vprintf(fmt, args);
202 va_end(args);
203 }
204 return ret;
205 }
206
207
208 static int print_block_option_help(const char *filename, const char *fmt)
209 {
210 BlockDriver *drv, *proto_drv;
211 QemuOptsList *create_opts = NULL;
212 Error *local_err = NULL;
213
214 /* Find driver and parse its options */
215 drv = bdrv_find_format(fmt);
216 if (!drv) {
217 error_report("Unknown file format '%s'", fmt);
218 return 1;
219 }
220
221 create_opts = qemu_opts_append(create_opts, drv->create_opts);
222 if (filename) {
223 proto_drv = bdrv_find_protocol(filename, true, &local_err);
224 if (!proto_drv) {
225 error_report_err(local_err);
226 qemu_opts_free(create_opts);
227 return 1;
228 }
229 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
230 }
231
232 qemu_opts_print_help(create_opts);
233 qemu_opts_free(create_opts);
234 return 0;
235 }
236
237
238 static int img_open_password(BlockBackend *blk, const char *filename,
239 int flags, bool quiet)
240 {
241 BlockDriverState *bs;
242 char password[256];
243
244 bs = blk_bs(blk);
245 if (bdrv_is_encrypted(bs) && bdrv_key_required(bs) &&
246 !(flags & BDRV_O_NO_IO)) {
247 qprintf(quiet, "Disk image '%s' is encrypted.\n", filename);
248 if (qemu_read_password(password, sizeof(password)) < 0) {
249 error_report("No password given");
250 return -1;
251 }
252 if (bdrv_set_key(bs, password) < 0) {
253 error_report("invalid password");
254 return -1;
255 }
256 }
257 return 0;
258 }
259
260
261 static BlockBackend *img_open_opts(const char *optstr,
262 QemuOpts *opts, int flags, bool writethrough,
263 bool quiet)
264 {
265 QDict *options;
266 Error *local_err = NULL;
267 BlockBackend *blk;
268 options = qemu_opts_to_qdict(opts, NULL);
269 blk = blk_new_open(NULL, NULL, options, flags, &local_err);
270 if (!blk) {
271 error_reportf_err(local_err, "Could not open '%s': ", optstr);
272 return NULL;
273 }
274 blk_set_enable_write_cache(blk, !writethrough);
275
276 if (img_open_password(blk, optstr, flags, quiet) < 0) {
277 blk_unref(blk);
278 return NULL;
279 }
280 return blk;
281 }
282
283 static BlockBackend *img_open_file(const char *filename,
284 const char *fmt, int flags,
285 bool writethrough, bool quiet)
286 {
287 BlockBackend *blk;
288 Error *local_err = NULL;
289 QDict *options = NULL;
290
291 if (fmt) {
292 options = qdict_new();
293 qdict_put(options, "driver", qstring_from_str(fmt));
294 }
295
296 blk = blk_new_open(filename, NULL, options, flags, &local_err);
297 if (!blk) {
298 error_reportf_err(local_err, "Could not open '%s': ", filename);
299 return NULL;
300 }
301 blk_set_enable_write_cache(blk, !writethrough);
302
303 if (img_open_password(blk, filename, flags, quiet) < 0) {
304 blk_unref(blk);
305 return NULL;
306 }
307 return blk;
308 }
309
310
311 static BlockBackend *img_open(bool image_opts,
312 const char *filename,
313 const char *fmt, int flags, bool writethrough,
314 bool quiet)
315 {
316 BlockBackend *blk;
317 if (image_opts) {
318 QemuOpts *opts;
319 if (fmt) {
320 error_report("--image-opts and --format are mutually exclusive");
321 return NULL;
322 }
323 opts = qemu_opts_parse_noisily(qemu_find_opts("source"),
324 filename, true);
325 if (!opts) {
326 return NULL;
327 }
328 blk = img_open_opts(filename, opts, flags, writethrough, quiet);
329 } else {
330 blk = img_open_file(filename, fmt, flags, writethrough, quiet);
331 }
332 return blk;
333 }
334
335
336 static int add_old_style_options(const char *fmt, QemuOpts *opts,
337 const char *base_filename,
338 const char *base_fmt)
339 {
340 Error *err = NULL;
341
342 if (base_filename) {
343 qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &err);
344 if (err) {
345 error_report("Backing file not supported for file format '%s'",
346 fmt);
347 error_free(err);
348 return -1;
349 }
350 }
351 if (base_fmt) {
352 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &err);
353 if (err) {
354 error_report("Backing file format not supported for file "
355 "format '%s'", fmt);
356 error_free(err);
357 return -1;
358 }
359 }
360 return 0;
361 }
362
363 static int img_create(int argc, char **argv)
364 {
365 int c;
366 uint64_t img_size = -1;
367 const char *fmt = "raw";
368 const char *base_fmt = NULL;
369 const char *filename;
370 const char *base_filename = NULL;
371 char *options = NULL;
372 Error *local_err = NULL;
373 bool quiet = false;
374
375 for(;;) {
376 static const struct option long_options[] = {
377 {"help", no_argument, 0, 'h'},
378 {"object", required_argument, 0, OPTION_OBJECT},
379 {0, 0, 0, 0}
380 };
381 c = getopt_long(argc, argv, "F:b:f:he6o:q",
382 long_options, NULL);
383 if (c == -1) {
384 break;
385 }
386 switch(c) {
387 case '?':
388 case 'h':
389 help();
390 break;
391 case 'F':
392 base_fmt = optarg;
393 break;
394 case 'b':
395 base_filename = optarg;
396 break;
397 case 'f':
398 fmt = optarg;
399 break;
400 case 'e':
401 error_report("option -e is deprecated, please use \'-o "
402 "encryption\' instead!");
403 goto fail;
404 case '6':
405 error_report("option -6 is deprecated, please use \'-o "
406 "compat6\' instead!");
407 goto fail;
408 case 'o':
409 if (!is_valid_option_list(optarg)) {
410 error_report("Invalid option list: %s", optarg);
411 goto fail;
412 }
413 if (!options) {
414 options = g_strdup(optarg);
415 } else {
416 char *old_options = options;
417 options = g_strdup_printf("%s,%s", options, optarg);
418 g_free(old_options);
419 }
420 break;
421 case 'q':
422 quiet = true;
423 break;
424 case OPTION_OBJECT: {
425 QemuOpts *opts;
426 opts = qemu_opts_parse_noisily(&qemu_object_opts,
427 optarg, true);
428 if (!opts) {
429 goto fail;
430 }
431 } break;
432 }
433 }
434
435 /* Get the filename */
436 filename = (optind < argc) ? argv[optind] : NULL;
437 if (options && has_help_option(options)) {
438 g_free(options);
439 return print_block_option_help(filename, fmt);
440 }
441
442 if (optind >= argc) {
443 error_exit("Expecting image file name");
444 }
445 optind++;
446
447 if (qemu_opts_foreach(&qemu_object_opts,
448 user_creatable_add_opts_foreach,
449 NULL, NULL)) {
450 goto fail;
451 }
452
453 /* Get image size, if specified */
454 if (optind < argc) {
455 int64_t sval;
456 char *end;
457 sval = qemu_strtosz_suffix(argv[optind++], &end,
458 QEMU_STRTOSZ_DEFSUFFIX_B);
459 if (sval < 0 || *end) {
460 if (sval == -ERANGE) {
461 error_report("Image size must be less than 8 EiB!");
462 } else {
463 error_report("Invalid image size specified! You may use k, M, "
464 "G, T, P or E suffixes for ");
465 error_report("kilobytes, megabytes, gigabytes, terabytes, "
466 "petabytes and exabytes.");
467 }
468 goto fail;
469 }
470 img_size = (uint64_t)sval;
471 }
472 if (optind != argc) {
473 error_exit("Unexpected argument: %s", argv[optind]);
474 }
475
476 bdrv_img_create(filename, fmt, base_filename, base_fmt,
477 options, img_size, 0, &local_err, quiet);
478 if (local_err) {
479 error_reportf_err(local_err, "%s: ", filename);
480 goto fail;
481 }
482
483 g_free(options);
484 return 0;
485
486 fail:
487 g_free(options);
488 return 1;
489 }
490
491 static void dump_json_image_check(ImageCheck *check, bool quiet)
492 {
493 QString *str;
494 QObject *obj;
495 Visitor *v = qmp_output_visitor_new(&obj);
496
497 visit_type_ImageCheck(v, NULL, &check, &error_abort);
498 visit_complete(v, &obj);
499 str = qobject_to_json_pretty(obj);
500 assert(str != NULL);
501 qprintf(quiet, "%s\n", qstring_get_str(str));
502 qobject_decref(obj);
503 visit_free(v);
504 QDECREF(str);
505 }
506
507 static void dump_human_image_check(ImageCheck *check, bool quiet)
508 {
509 if (!(check->corruptions || check->leaks || check->check_errors)) {
510 qprintf(quiet, "No errors were found on the image.\n");
511 } else {
512 if (check->corruptions) {
513 qprintf(quiet, "\n%" PRId64 " errors were found on the image.\n"
514 "Data may be corrupted, or further writes to the image "
515 "may corrupt it.\n",
516 check->corruptions);
517 }
518
519 if (check->leaks) {
520 qprintf(quiet,
521 "\n%" PRId64 " leaked clusters were found on the image.\n"
522 "This means waste of disk space, but no harm to data.\n",
523 check->leaks);
524 }
525
526 if (check->check_errors) {
527 qprintf(quiet,
528 "\n%" PRId64
529 " internal errors have occurred during the check.\n",
530 check->check_errors);
531 }
532 }
533
534 if (check->total_clusters != 0 && check->allocated_clusters != 0) {
535 qprintf(quiet, "%" PRId64 "/%" PRId64 " = %0.2f%% allocated, "
536 "%0.2f%% fragmented, %0.2f%% compressed clusters\n",
537 check->allocated_clusters, check->total_clusters,
538 check->allocated_clusters * 100.0 / check->total_clusters,
539 check->fragmented_clusters * 100.0 / check->allocated_clusters,
540 check->compressed_clusters * 100.0 /
541 check->allocated_clusters);
542 }
543
544 if (check->image_end_offset) {
545 qprintf(quiet,
546 "Image end offset: %" PRId64 "\n", check->image_end_offset);
547 }
548 }
549
550 static int collect_image_check(BlockDriverState *bs,
551 ImageCheck *check,
552 const char *filename,
553 const char *fmt,
554 int fix)
555 {
556 int ret;
557 BdrvCheckResult result;
558
559 ret = bdrv_check(bs, &result, fix);
560 if (ret < 0) {
561 return ret;
562 }
563
564 check->filename = g_strdup(filename);
565 check->format = g_strdup(bdrv_get_format_name(bs));
566 check->check_errors = result.check_errors;
567 check->corruptions = result.corruptions;
568 check->has_corruptions = result.corruptions != 0;
569 check->leaks = result.leaks;
570 check->has_leaks = result.leaks != 0;
571 check->corruptions_fixed = result.corruptions_fixed;
572 check->has_corruptions_fixed = result.corruptions != 0;
573 check->leaks_fixed = result.leaks_fixed;
574 check->has_leaks_fixed = result.leaks != 0;
575 check->image_end_offset = result.image_end_offset;
576 check->has_image_end_offset = result.image_end_offset != 0;
577 check->total_clusters = result.bfi.total_clusters;
578 check->has_total_clusters = result.bfi.total_clusters != 0;
579 check->allocated_clusters = result.bfi.allocated_clusters;
580 check->has_allocated_clusters = result.bfi.allocated_clusters != 0;
581 check->fragmented_clusters = result.bfi.fragmented_clusters;
582 check->has_fragmented_clusters = result.bfi.fragmented_clusters != 0;
583 check->compressed_clusters = result.bfi.compressed_clusters;
584 check->has_compressed_clusters = result.bfi.compressed_clusters != 0;
585
586 return 0;
587 }
588
589 /*
590 * Checks an image for consistency. Exit codes:
591 *
592 * 0 - Check completed, image is good
593 * 1 - Check not completed because of internal errors
594 * 2 - Check completed, image is corrupted
595 * 3 - Check completed, image has leaked clusters, but is good otherwise
596 * 63 - Checks are not supported by the image format
597 */
598 static int img_check(int argc, char **argv)
599 {
600 int c, ret;
601 OutputFormat output_format = OFORMAT_HUMAN;
602 const char *filename, *fmt, *output, *cache;
603 BlockBackend *blk;
604 BlockDriverState *bs;
605 int fix = 0;
606 int flags = BDRV_O_CHECK;
607 bool writethrough;
608 ImageCheck *check;
609 bool quiet = false;
610 bool image_opts = false;
611
612 fmt = NULL;
613 output = NULL;
614 cache = BDRV_DEFAULT_CACHE;
615
616 for(;;) {
617 int option_index = 0;
618 static const struct option long_options[] = {
619 {"help", no_argument, 0, 'h'},
620 {"format", required_argument, 0, 'f'},
621 {"repair", required_argument, 0, 'r'},
622 {"output", required_argument, 0, OPTION_OUTPUT},
623 {"object", required_argument, 0, OPTION_OBJECT},
624 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
625 {0, 0, 0, 0}
626 };
627 c = getopt_long(argc, argv, "hf:r:T:q",
628 long_options, &option_index);
629 if (c == -1) {
630 break;
631 }
632 switch(c) {
633 case '?':
634 case 'h':
635 help();
636 break;
637 case 'f':
638 fmt = optarg;
639 break;
640 case 'r':
641 flags |= BDRV_O_RDWR;
642
643 if (!strcmp(optarg, "leaks")) {
644 fix = BDRV_FIX_LEAKS;
645 } else if (!strcmp(optarg, "all")) {
646 fix = BDRV_FIX_LEAKS | BDRV_FIX_ERRORS;
647 } else {
648 error_exit("Unknown option value for -r "
649 "(expecting 'leaks' or 'all'): %s", optarg);
650 }
651 break;
652 case OPTION_OUTPUT:
653 output = optarg;
654 break;
655 case 'T':
656 cache = optarg;
657 break;
658 case 'q':
659 quiet = true;
660 break;
661 case OPTION_OBJECT: {
662 QemuOpts *opts;
663 opts = qemu_opts_parse_noisily(&qemu_object_opts,
664 optarg, true);
665 if (!opts) {
666 return 1;
667 }
668 } break;
669 case OPTION_IMAGE_OPTS:
670 image_opts = true;
671 break;
672 }
673 }
674 if (optind != argc - 1) {
675 error_exit("Expecting one image file name");
676 }
677 filename = argv[optind++];
678
679 if (output && !strcmp(output, "json")) {
680 output_format = OFORMAT_JSON;
681 } else if (output && !strcmp(output, "human")) {
682 output_format = OFORMAT_HUMAN;
683 } else if (output) {
684 error_report("--output must be used with human or json as argument.");
685 return 1;
686 }
687
688 if (qemu_opts_foreach(&qemu_object_opts,
689 user_creatable_add_opts_foreach,
690 NULL, NULL)) {
691 return 1;
692 }
693
694 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
695 if (ret < 0) {
696 error_report("Invalid source cache option: %s", cache);
697 return 1;
698 }
699
700 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet);
701 if (!blk) {
702 return 1;
703 }
704 bs = blk_bs(blk);
705
706 check = g_new0(ImageCheck, 1);
707 ret = collect_image_check(bs, check, filename, fmt, fix);
708
709 if (ret == -ENOTSUP) {
710 error_report("This image format does not support checks");
711 ret = 63;
712 goto fail;
713 }
714
715 if (check->corruptions_fixed || check->leaks_fixed) {
716 int corruptions_fixed, leaks_fixed;
717
718 leaks_fixed = check->leaks_fixed;
719 corruptions_fixed = check->corruptions_fixed;
720
721 if (output_format == OFORMAT_HUMAN) {
722 qprintf(quiet,
723 "The following inconsistencies were found and repaired:\n\n"
724 " %" PRId64 " leaked clusters\n"
725 " %" PRId64 " corruptions\n\n"
726 "Double checking the fixed image now...\n",
727 check->leaks_fixed,
728 check->corruptions_fixed);
729 }
730
731 ret = collect_image_check(bs, check, filename, fmt, 0);
732
733 check->leaks_fixed = leaks_fixed;
734 check->corruptions_fixed = corruptions_fixed;
735 }
736
737 if (!ret) {
738 switch (output_format) {
739 case OFORMAT_HUMAN:
740 dump_human_image_check(check, quiet);
741 break;
742 case OFORMAT_JSON:
743 dump_json_image_check(check, quiet);
744 break;
745 }
746 }
747
748 if (ret || check->check_errors) {
749 if (ret) {
750 error_report("Check failed: %s", strerror(-ret));
751 } else {
752 error_report("Check failed");
753 }
754 ret = 1;
755 goto fail;
756 }
757
758 if (check->corruptions) {
759 ret = 2;
760 } else if (check->leaks) {
761 ret = 3;
762 } else {
763 ret = 0;
764 }
765
766 fail:
767 qapi_free_ImageCheck(check);
768 blk_unref(blk);
769 return ret;
770 }
771
772 typedef struct CommonBlockJobCBInfo {
773 BlockDriverState *bs;
774 Error **errp;
775 } CommonBlockJobCBInfo;
776
777 static void common_block_job_cb(void *opaque, int ret)
778 {
779 CommonBlockJobCBInfo *cbi = opaque;
780
781 if (ret < 0) {
782 error_setg_errno(cbi->errp, -ret, "Block job failed");
783 }
784 }
785
786 static void run_block_job(BlockJob *job, Error **errp)
787 {
788 AioContext *aio_context = blk_get_aio_context(job->blk);
789
790 do {
791 aio_poll(aio_context, true);
792 qemu_progress_print(job->len ?
793 ((float)job->offset / job->len * 100.f) : 0.0f, 0);
794 } while (!job->ready);
795
796 block_job_complete_sync(job, errp);
797
798 /* A block job may finish instantaneously without publishing any progress,
799 * so just signal completion here */
800 qemu_progress_print(100.f, 0);
801 }
802
803 static int img_commit(int argc, char **argv)
804 {
805 int c, ret, flags;
806 const char *filename, *fmt, *cache, *base;
807 BlockBackend *blk;
808 BlockDriverState *bs, *base_bs;
809 bool progress = false, quiet = false, drop = false;
810 bool writethrough;
811 Error *local_err = NULL;
812 CommonBlockJobCBInfo cbi;
813 bool image_opts = false;
814
815 fmt = NULL;
816 cache = BDRV_DEFAULT_CACHE;
817 base = NULL;
818 for(;;) {
819 static const struct option long_options[] = {
820 {"help", no_argument, 0, 'h'},
821 {"object", required_argument, 0, OPTION_OBJECT},
822 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
823 {0, 0, 0, 0}
824 };
825 c = getopt_long(argc, argv, "f:ht:b:dpq",
826 long_options, NULL);
827 if (c == -1) {
828 break;
829 }
830 switch(c) {
831 case '?':
832 case 'h':
833 help();
834 break;
835 case 'f':
836 fmt = optarg;
837 break;
838 case 't':
839 cache = optarg;
840 break;
841 case 'b':
842 base = optarg;
843 /* -b implies -d */
844 drop = true;
845 break;
846 case 'd':
847 drop = true;
848 break;
849 case 'p':
850 progress = true;
851 break;
852 case 'q':
853 quiet = true;
854 break;
855 case OPTION_OBJECT: {
856 QemuOpts *opts;
857 opts = qemu_opts_parse_noisily(&qemu_object_opts,
858 optarg, true);
859 if (!opts) {
860 return 1;
861 }
862 } break;
863 case OPTION_IMAGE_OPTS:
864 image_opts = true;
865 break;
866 }
867 }
868
869 /* Progress is not shown in Quiet mode */
870 if (quiet) {
871 progress = false;
872 }
873
874 if (optind != argc - 1) {
875 error_exit("Expecting one image file name");
876 }
877 filename = argv[optind++];
878
879 if (qemu_opts_foreach(&qemu_object_opts,
880 user_creatable_add_opts_foreach,
881 NULL, NULL)) {
882 return 1;
883 }
884
885 flags = BDRV_O_RDWR | BDRV_O_UNMAP;
886 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
887 if (ret < 0) {
888 error_report("Invalid cache option: %s", cache);
889 return 1;
890 }
891
892 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet);
893 if (!blk) {
894 return 1;
895 }
896 bs = blk_bs(blk);
897
898 qemu_progress_init(progress, 1.f);
899 qemu_progress_print(0.f, 100);
900
901 if (base) {
902 base_bs = bdrv_find_backing_image(bs, base);
903 if (!base_bs) {
904 error_setg(&local_err, QERR_BASE_NOT_FOUND, base);
905 goto done;
906 }
907 } else {
908 /* This is different from QMP, which by default uses the deepest file in
909 * the backing chain (i.e., the very base); however, the traditional
910 * behavior of qemu-img commit is using the immediate backing file. */
911 base_bs = backing_bs(bs);
912 if (!base_bs) {
913 error_setg(&local_err, "Image does not have a backing file");
914 goto done;
915 }
916 }
917
918 cbi = (CommonBlockJobCBInfo){
919 .errp = &local_err,
920 .bs = bs,
921 };
922
923 commit_active_start(bs, base_bs, 0, BLOCKDEV_ON_ERROR_REPORT,
924 common_block_job_cb, &cbi, &local_err);
925 if (local_err) {
926 goto done;
927 }
928
929 /* When the block job completes, the BlockBackend reference will point to
930 * the old backing file. In order to avoid that the top image is already
931 * deleted, so we can still empty it afterwards, increment the reference
932 * counter here preemptively. */
933 if (!drop) {
934 bdrv_ref(bs);
935 }
936
937 run_block_job(bs->job, &local_err);
938 if (local_err) {
939 goto unref_backing;
940 }
941
942 if (!drop && bs->drv->bdrv_make_empty) {
943 ret = bs->drv->bdrv_make_empty(bs);
944 if (ret) {
945 error_setg_errno(&local_err, -ret, "Could not empty %s",
946 filename);
947 goto unref_backing;
948 }
949 }
950
951 unref_backing:
952 if (!drop) {
953 bdrv_unref(bs);
954 }
955
956 done:
957 qemu_progress_end();
958
959 blk_unref(blk);
960
961 if (local_err) {
962 error_report_err(local_err);
963 return 1;
964 }
965
966 qprintf(quiet, "Image committed.\n");
967 return 0;
968 }
969
970 /*
971 * Returns true iff the first sector pointed to by 'buf' contains at least
972 * a non-NUL byte.
973 *
974 * 'pnum' is set to the number of sectors (including and immediately following
975 * the first one) that are known to be in the same allocated/unallocated state.
976 */
977 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
978 {
979 bool is_zero;
980 int i;
981
982 if (n <= 0) {
983 *pnum = 0;
984 return 0;
985 }
986 is_zero = buffer_is_zero(buf, 512);
987 for(i = 1; i < n; i++) {
988 buf += 512;
989 if (is_zero != buffer_is_zero(buf, 512)) {
990 break;
991 }
992 }
993 *pnum = i;
994 return !is_zero;
995 }
996
997 /*
998 * Like is_allocated_sectors, but if the buffer starts with a used sector,
999 * up to 'min' consecutive sectors containing zeros are ignored. This avoids
1000 * breaking up write requests for only small sparse areas.
1001 */
1002 static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
1003 int min)
1004 {
1005 int ret;
1006 int num_checked, num_used;
1007
1008 if (n < min) {
1009 min = n;
1010 }
1011
1012 ret = is_allocated_sectors(buf, n, pnum);
1013 if (!ret) {
1014 return ret;
1015 }
1016
1017 num_used = *pnum;
1018 buf += BDRV_SECTOR_SIZE * *pnum;
1019 n -= *pnum;
1020 num_checked = num_used;
1021
1022 while (n > 0) {
1023 ret = is_allocated_sectors(buf, n, pnum);
1024
1025 buf += BDRV_SECTOR_SIZE * *pnum;
1026 n -= *pnum;
1027 num_checked += *pnum;
1028 if (ret) {
1029 num_used = num_checked;
1030 } else if (*pnum >= min) {
1031 break;
1032 }
1033 }
1034
1035 *pnum = num_used;
1036 return 1;
1037 }
1038
1039 /*
1040 * Compares two buffers sector by sector. Returns 0 if the first sector of both
1041 * buffers matches, non-zero otherwise.
1042 *
1043 * pnum is set to the number of sectors (including and immediately following
1044 * the first one) that are known to have the same comparison result
1045 */
1046 static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
1047 int *pnum)
1048 {
1049 bool res;
1050 int i;
1051
1052 if (n <= 0) {
1053 *pnum = 0;
1054 return 0;
1055 }
1056
1057 res = !!memcmp(buf1, buf2, 512);
1058 for(i = 1; i < n; i++) {
1059 buf1 += 512;
1060 buf2 += 512;
1061
1062 if (!!memcmp(buf1, buf2, 512) != res) {
1063 break;
1064 }
1065 }
1066
1067 *pnum = i;
1068 return res;
1069 }
1070
1071 #define IO_BUF_SIZE (2 * 1024 * 1024)
1072
1073 static int64_t sectors_to_bytes(int64_t sectors)
1074 {
1075 return sectors << BDRV_SECTOR_BITS;
1076 }
1077
1078 static int64_t sectors_to_process(int64_t total, int64_t from)
1079 {
1080 return MIN(total - from, IO_BUF_SIZE >> BDRV_SECTOR_BITS);
1081 }
1082
1083 /*
1084 * Check if passed sectors are empty (not allocated or contain only 0 bytes)
1085 *
1086 * Returns 0 in case sectors are filled with 0, 1 if sectors contain non-zero
1087 * data and negative value on error.
1088 *
1089 * @param blk: BlockBackend for the image
1090 * @param sect_num: Number of first sector to check
1091 * @param sect_count: Number of sectors to check
1092 * @param filename: Name of disk file we are checking (logging purpose)
1093 * @param buffer: Allocated buffer for storing read data
1094 * @param quiet: Flag for quiet mode
1095 */
1096 static int check_empty_sectors(BlockBackend *blk, int64_t sect_num,
1097 int sect_count, const char *filename,
1098 uint8_t *buffer, bool quiet)
1099 {
1100 int pnum, ret = 0;
1101 ret = blk_pread(blk, sect_num << BDRV_SECTOR_BITS, buffer,
1102 sect_count << BDRV_SECTOR_BITS);
1103 if (ret < 0) {
1104 error_report("Error while reading offset %" PRId64 " of %s: %s",
1105 sectors_to_bytes(sect_num), filename, strerror(-ret));
1106 return ret;
1107 }
1108 ret = is_allocated_sectors(buffer, sect_count, &pnum);
1109 if (ret || pnum != sect_count) {
1110 qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
1111 sectors_to_bytes(ret ? sect_num : sect_num + pnum));
1112 return 1;
1113 }
1114
1115 return 0;
1116 }
1117
1118 /*
1119 * Compares two images. Exit codes:
1120 *
1121 * 0 - Images are identical
1122 * 1 - Images differ
1123 * >1 - Error occurred
1124 */
1125 static int img_compare(int argc, char **argv)
1126 {
1127 const char *fmt1 = NULL, *fmt2 = NULL, *cache, *filename1, *filename2;
1128 BlockBackend *blk1, *blk2;
1129 BlockDriverState *bs1, *bs2;
1130 int64_t total_sectors1, total_sectors2;
1131 uint8_t *buf1 = NULL, *buf2 = NULL;
1132 int pnum1, pnum2;
1133 int allocated1, allocated2;
1134 int ret = 0; /* return value - 0 Ident, 1 Different, >1 Error */
1135 bool progress = false, quiet = false, strict = false;
1136 int flags;
1137 bool writethrough;
1138 int64_t total_sectors;
1139 int64_t sector_num = 0;
1140 int64_t nb_sectors;
1141 int c, pnum;
1142 uint64_t progress_base;
1143 bool image_opts = false;
1144
1145 cache = BDRV_DEFAULT_CACHE;
1146 for (;;) {
1147 static const struct option long_options[] = {
1148 {"help", no_argument, 0, 'h'},
1149 {"object", required_argument, 0, OPTION_OBJECT},
1150 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
1151 {0, 0, 0, 0}
1152 };
1153 c = getopt_long(argc, argv, "hf:F:T:pqs",
1154 long_options, NULL);
1155 if (c == -1) {
1156 break;
1157 }
1158 switch (c) {
1159 case '?':
1160 case 'h':
1161 help();
1162 break;
1163 case 'f':
1164 fmt1 = optarg;
1165 break;
1166 case 'F':
1167 fmt2 = optarg;
1168 break;
1169 case 'T':
1170 cache = optarg;
1171 break;
1172 case 'p':
1173 progress = true;
1174 break;
1175 case 'q':
1176 quiet = true;
1177 break;
1178 case 's':
1179 strict = true;
1180 break;
1181 case OPTION_OBJECT: {
1182 QemuOpts *opts;
1183 opts = qemu_opts_parse_noisily(&qemu_object_opts,
1184 optarg, true);
1185 if (!opts) {
1186 ret = 2;
1187 goto out4;
1188 }
1189 } break;
1190 case OPTION_IMAGE_OPTS:
1191 image_opts = true;
1192 break;
1193 }
1194 }
1195
1196 /* Progress is not shown in Quiet mode */
1197 if (quiet) {
1198 progress = false;
1199 }
1200
1201
1202 if (optind != argc - 2) {
1203 error_exit("Expecting two image file names");
1204 }
1205 filename1 = argv[optind++];
1206 filename2 = argv[optind++];
1207
1208 if (qemu_opts_foreach(&qemu_object_opts,
1209 user_creatable_add_opts_foreach,
1210 NULL, NULL)) {
1211 ret = 2;
1212 goto out4;
1213 }
1214
1215 /* Initialize before goto out */
1216 qemu_progress_init(progress, 2.0);
1217
1218 flags = 0;
1219 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
1220 if (ret < 0) {
1221 error_report("Invalid source cache option: %s", cache);
1222 ret = 2;
1223 goto out3;
1224 }
1225
1226 blk1 = img_open(image_opts, filename1, fmt1, flags, writethrough, quiet);
1227 if (!blk1) {
1228 ret = 2;
1229 goto out3;
1230 }
1231
1232 blk2 = img_open(image_opts, filename2, fmt2, flags, writethrough, quiet);
1233 if (!blk2) {
1234 ret = 2;
1235 goto out2;
1236 }
1237 bs1 = blk_bs(blk1);
1238 bs2 = blk_bs(blk2);
1239
1240 buf1 = blk_blockalign(blk1, IO_BUF_SIZE);
1241 buf2 = blk_blockalign(blk2, IO_BUF_SIZE);
1242 total_sectors1 = blk_nb_sectors(blk1);
1243 if (total_sectors1 < 0) {
1244 error_report("Can't get size of %s: %s",
1245 filename1, strerror(-total_sectors1));
1246 ret = 4;
1247 goto out;
1248 }
1249 total_sectors2 = blk_nb_sectors(blk2);
1250 if (total_sectors2 < 0) {
1251 error_report("Can't get size of %s: %s",
1252 filename2, strerror(-total_sectors2));
1253 ret = 4;
1254 goto out;
1255 }
1256 total_sectors = MIN(total_sectors1, total_sectors2);
1257 progress_base = MAX(total_sectors1, total_sectors2);
1258
1259 qemu_progress_print(0, 100);
1260
1261 if (strict && total_sectors1 != total_sectors2) {
1262 ret = 1;
1263 qprintf(quiet, "Strict mode: Image size mismatch!\n");
1264 goto out;
1265 }
1266
1267 for (;;) {
1268 int64_t status1, status2;
1269 BlockDriverState *file;
1270
1271 nb_sectors = sectors_to_process(total_sectors, sector_num);
1272 if (nb_sectors <= 0) {
1273 break;
1274 }
1275 status1 = bdrv_get_block_status_above(bs1, NULL, sector_num,
1276 total_sectors1 - sector_num,
1277 &pnum1, &file);
1278 if (status1 < 0) {
1279 ret = 3;
1280 error_report("Sector allocation test failed for %s", filename1);
1281 goto out;
1282 }
1283 allocated1 = status1 & BDRV_BLOCK_ALLOCATED;
1284
1285 status2 = bdrv_get_block_status_above(bs2, NULL, sector_num,
1286 total_sectors2 - sector_num,
1287 &pnum2, &file);
1288 if (status2 < 0) {
1289 ret = 3;
1290 error_report("Sector allocation test failed for %s", filename2);
1291 goto out;
1292 }
1293 allocated2 = status2 & BDRV_BLOCK_ALLOCATED;
1294 if (pnum1) {
1295 nb_sectors = MIN(nb_sectors, pnum1);
1296 }
1297 if (pnum2) {
1298 nb_sectors = MIN(nb_sectors, pnum2);
1299 }
1300
1301 if (strict) {
1302 if ((status1 & ~BDRV_BLOCK_OFFSET_MASK) !=
1303 (status2 & ~BDRV_BLOCK_OFFSET_MASK)) {
1304 ret = 1;
1305 qprintf(quiet, "Strict mode: Offset %" PRId64
1306 " block status mismatch!\n",
1307 sectors_to_bytes(sector_num));
1308 goto out;
1309 }
1310 }
1311 if ((status1 & BDRV_BLOCK_ZERO) && (status2 & BDRV_BLOCK_ZERO)) {
1312 nb_sectors = MIN(pnum1, pnum2);
1313 } else if (allocated1 == allocated2) {
1314 if (allocated1) {
1315 ret = blk_pread(blk1, sector_num << BDRV_SECTOR_BITS, buf1,
1316 nb_sectors << BDRV_SECTOR_BITS);
1317 if (ret < 0) {
1318 error_report("Error while reading offset %" PRId64 " of %s:"
1319 " %s", sectors_to_bytes(sector_num), filename1,
1320 strerror(-ret));
1321 ret = 4;
1322 goto out;
1323 }
1324 ret = blk_pread(blk2, sector_num << BDRV_SECTOR_BITS, buf2,
1325 nb_sectors << BDRV_SECTOR_BITS);
1326 if (ret < 0) {
1327 error_report("Error while reading offset %" PRId64
1328 " of %s: %s", sectors_to_bytes(sector_num),
1329 filename2, strerror(-ret));
1330 ret = 4;
1331 goto out;
1332 }
1333 ret = compare_sectors(buf1, buf2, nb_sectors, &pnum);
1334 if (ret || pnum != nb_sectors) {
1335 qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
1336 sectors_to_bytes(
1337 ret ? sector_num : sector_num + pnum));
1338 ret = 1;
1339 goto out;
1340 }
1341 }
1342 } else {
1343
1344 if (allocated1) {
1345 ret = check_empty_sectors(blk1, sector_num, nb_sectors,
1346 filename1, buf1, quiet);
1347 } else {
1348 ret = check_empty_sectors(blk2, sector_num, nb_sectors,
1349 filename2, buf1, quiet);
1350 }
1351 if (ret) {
1352 if (ret < 0) {
1353 error_report("Error while reading offset %" PRId64 ": %s",
1354 sectors_to_bytes(sector_num), strerror(-ret));
1355 ret = 4;
1356 }
1357 goto out;
1358 }
1359 }
1360 sector_num += nb_sectors;
1361 qemu_progress_print(((float) nb_sectors / progress_base)*100, 100);
1362 }
1363
1364 if (total_sectors1 != total_sectors2) {
1365 BlockBackend *blk_over;
1366 int64_t total_sectors_over;
1367 const char *filename_over;
1368
1369 qprintf(quiet, "Warning: Image size mismatch!\n");
1370 if (total_sectors1 > total_sectors2) {
1371 total_sectors_over = total_sectors1;
1372 blk_over = blk1;
1373 filename_over = filename1;
1374 } else {
1375 total_sectors_over = total_sectors2;
1376 blk_over = blk2;
1377 filename_over = filename2;
1378 }
1379
1380 for (;;) {
1381 nb_sectors = sectors_to_process(total_sectors_over, sector_num);
1382 if (nb_sectors <= 0) {
1383 break;
1384 }
1385 ret = bdrv_is_allocated_above(blk_bs(blk_over), NULL, sector_num,
1386 nb_sectors, &pnum);
1387 if (ret < 0) {
1388 ret = 3;
1389 error_report("Sector allocation test failed for %s",
1390 filename_over);
1391 goto out;
1392
1393 }
1394 nb_sectors = pnum;
1395 if (ret) {
1396 ret = check_empty_sectors(blk_over, sector_num, nb_sectors,
1397 filename_over, buf1, quiet);
1398 if (ret) {
1399 if (ret < 0) {
1400 error_report("Error while reading offset %" PRId64
1401 " of %s: %s", sectors_to_bytes(sector_num),
1402 filename_over, strerror(-ret));
1403 ret = 4;
1404 }
1405 goto out;
1406 }
1407 }
1408 sector_num += nb_sectors;
1409 qemu_progress_print(((float) nb_sectors / progress_base)*100, 100);
1410 }
1411 }
1412
1413 qprintf(quiet, "Images are identical.\n");
1414 ret = 0;
1415
1416 out:
1417 qemu_vfree(buf1);
1418 qemu_vfree(buf2);
1419 blk_unref(blk2);
1420 out2:
1421 blk_unref(blk1);
1422 out3:
1423 qemu_progress_end();
1424 out4:
1425 return ret;
1426 }
1427
1428 enum ImgConvertBlockStatus {
1429 BLK_DATA,
1430 BLK_ZERO,
1431 BLK_BACKING_FILE,
1432 };
1433
1434 typedef struct ImgConvertState {
1435 BlockBackend **src;
1436 int64_t *src_sectors;
1437 int src_cur, src_num;
1438 int64_t src_cur_offset;
1439 int64_t total_sectors;
1440 int64_t allocated_sectors;
1441 enum ImgConvertBlockStatus status;
1442 int64_t sector_next_status;
1443 BlockBackend *target;
1444 bool has_zero_init;
1445 bool compressed;
1446 bool target_has_backing;
1447 int min_sparse;
1448 size_t cluster_sectors;
1449 size_t buf_sectors;
1450 } ImgConvertState;
1451
1452 static void convert_select_part(ImgConvertState *s, int64_t sector_num)
1453 {
1454 assert(sector_num >= s->src_cur_offset);
1455 while (sector_num - s->src_cur_offset >= s->src_sectors[s->src_cur]) {
1456 s->src_cur_offset += s->src_sectors[s->src_cur];
1457 s->src_cur++;
1458 assert(s->src_cur < s->src_num);
1459 }
1460 }
1461
1462 static int convert_iteration_sectors(ImgConvertState *s, int64_t sector_num)
1463 {
1464 int64_t ret;
1465 int n;
1466
1467 convert_select_part(s, sector_num);
1468
1469 assert(s->total_sectors > sector_num);
1470 n = MIN(s->total_sectors - sector_num, BDRV_REQUEST_MAX_SECTORS);
1471
1472 if (s->sector_next_status <= sector_num) {
1473 BlockDriverState *file;
1474 ret = bdrv_get_block_status(blk_bs(s->src[s->src_cur]),
1475 sector_num - s->src_cur_offset,
1476 n, &n, &file);
1477 if (ret < 0) {
1478 return ret;
1479 }
1480
1481 if (ret & BDRV_BLOCK_ZERO) {
1482 s->status = BLK_ZERO;
1483 } else if (ret & BDRV_BLOCK_DATA) {
1484 s->status = BLK_DATA;
1485 } else if (!s->target_has_backing) {
1486 /* Without a target backing file we must copy over the contents of
1487 * the backing file as well. */
1488 /* Check block status of the backing file chain to avoid
1489 * needlessly reading zeroes and limiting the iteration to the
1490 * buffer size */
1491 ret = bdrv_get_block_status_above(blk_bs(s->src[s->src_cur]), NULL,
1492 sector_num - s->src_cur_offset,
1493 n, &n, &file);
1494 if (ret < 0) {
1495 return ret;
1496 }
1497
1498 if (ret & BDRV_BLOCK_ZERO) {
1499 s->status = BLK_ZERO;
1500 } else {
1501 s->status = BLK_DATA;
1502 }
1503 } else {
1504 s->status = BLK_BACKING_FILE;
1505 }
1506
1507 s->sector_next_status = sector_num + n;
1508 }
1509
1510 n = MIN(n, s->sector_next_status - sector_num);
1511 if (s->status == BLK_DATA) {
1512 n = MIN(n, s->buf_sectors);
1513 }
1514
1515 /* We need to write complete clusters for compressed images, so if an
1516 * unallocated area is shorter than that, we must consider the whole
1517 * cluster allocated. */
1518 if (s->compressed) {
1519 if (n < s->cluster_sectors) {
1520 n = MIN(s->cluster_sectors, s->total_sectors - sector_num);
1521 s->status = BLK_DATA;
1522 } else {
1523 n = QEMU_ALIGN_DOWN(n, s->cluster_sectors);
1524 }
1525 }
1526
1527 return n;
1528 }
1529
1530 static int convert_read(ImgConvertState *s, int64_t sector_num, int nb_sectors,
1531 uint8_t *buf)
1532 {
1533 int n;
1534 int ret;
1535
1536 assert(nb_sectors <= s->buf_sectors);
1537 while (nb_sectors > 0) {
1538 BlockBackend *blk;
1539 int64_t bs_sectors;
1540
1541 /* In the case of compression with multiple source files, we can get a
1542 * nb_sectors that spreads into the next part. So we must be able to
1543 * read across multiple BDSes for one convert_read() call. */
1544 convert_select_part(s, sector_num);
1545 blk = s->src[s->src_cur];
1546 bs_sectors = s->src_sectors[s->src_cur];
1547
1548 n = MIN(nb_sectors, bs_sectors - (sector_num - s->src_cur_offset));
1549 ret = blk_pread(blk,
1550 (sector_num - s->src_cur_offset) << BDRV_SECTOR_BITS,
1551 buf, n << BDRV_SECTOR_BITS);
1552 if (ret < 0) {
1553 return ret;
1554 }
1555
1556 sector_num += n;
1557 nb_sectors -= n;
1558 buf += n * BDRV_SECTOR_SIZE;
1559 }
1560
1561 return 0;
1562 }
1563
1564 static int convert_write(ImgConvertState *s, int64_t sector_num, int nb_sectors,
1565 const uint8_t *buf)
1566 {
1567 int ret;
1568
1569 while (nb_sectors > 0) {
1570 int n = nb_sectors;
1571
1572 switch (s->status) {
1573 case BLK_BACKING_FILE:
1574 /* If we have a backing file, leave clusters unallocated that are
1575 * unallocated in the source image, so that the backing file is
1576 * visible at the respective offset. */
1577 assert(s->target_has_backing);
1578 break;
1579
1580 case BLK_DATA:
1581 /* We must always write compressed clusters as a whole, so don't
1582 * try to find zeroed parts in the buffer. We can only save the
1583 * write if the buffer is completely zeroed and we're allowed to
1584 * keep the target sparse. */
1585 if (s->compressed) {
1586 if (s->has_zero_init && s->min_sparse &&
1587 buffer_is_zero(buf, n * BDRV_SECTOR_SIZE))
1588 {
1589 assert(!s->target_has_backing);
1590 break;
1591 }
1592
1593 ret = blk_write_compressed(s->target, sector_num, buf, n);
1594 if (ret < 0) {
1595 return ret;
1596 }
1597 break;
1598 }
1599
1600 /* If there is real non-zero data or we're told to keep the target
1601 * fully allocated (-S 0), we must write it. Otherwise we can treat
1602 * it as zero sectors. */
1603 if (!s->min_sparse ||
1604 is_allocated_sectors_min(buf, n, &n, s->min_sparse))
1605 {
1606 ret = blk_pwrite(s->target, sector_num << BDRV_SECTOR_BITS,
1607 buf, n << BDRV_SECTOR_BITS, 0);
1608 if (ret < 0) {
1609 return ret;
1610 }
1611 break;
1612 }
1613 /* fall-through */
1614
1615 case BLK_ZERO:
1616 if (s->has_zero_init) {
1617 break;
1618 }
1619 ret = blk_pwrite_zeroes(s->target, sector_num << BDRV_SECTOR_BITS,
1620 n << BDRV_SECTOR_BITS, 0);
1621 if (ret < 0) {
1622 return ret;
1623 }
1624 break;
1625 }
1626
1627 sector_num += n;
1628 nb_sectors -= n;
1629 buf += n * BDRV_SECTOR_SIZE;
1630 }
1631
1632 return 0;
1633 }
1634
1635 static int convert_do_copy(ImgConvertState *s)
1636 {
1637 uint8_t *buf = NULL;
1638 int64_t sector_num, allocated_done;
1639 int ret;
1640 int n;
1641
1642 /* Check whether we have zero initialisation or can get it efficiently */
1643 s->has_zero_init = s->min_sparse && !s->target_has_backing
1644 ? bdrv_has_zero_init(blk_bs(s->target))
1645 : false;
1646
1647 if (!s->has_zero_init && !s->target_has_backing &&
1648 bdrv_can_write_zeroes_with_unmap(blk_bs(s->target)))
1649 {
1650 ret = blk_make_zero(s->target, BDRV_REQ_MAY_UNMAP);
1651 if (ret == 0) {
1652 s->has_zero_init = true;
1653 }
1654 }
1655
1656 /* Allocate buffer for copied data. For compressed images, only one cluster
1657 * can be copied at a time. */
1658 if (s->compressed) {
1659 if (s->cluster_sectors <= 0 || s->cluster_sectors > s->buf_sectors) {
1660 error_report("invalid cluster size");
1661 ret = -EINVAL;
1662 goto fail;
1663 }
1664 s->buf_sectors = s->cluster_sectors;
1665 }
1666 buf = blk_blockalign(s->target, s->buf_sectors * BDRV_SECTOR_SIZE);
1667
1668 /* Calculate allocated sectors for progress */
1669 s->allocated_sectors = 0;
1670 sector_num = 0;
1671 while (sector_num < s->total_sectors) {
1672 n = convert_iteration_sectors(s, sector_num);
1673 if (n < 0) {
1674 ret = n;
1675 goto fail;
1676 }
1677 if (s->status == BLK_DATA || (!s->min_sparse && s->status == BLK_ZERO))
1678 {
1679 s->allocated_sectors += n;
1680 }
1681 sector_num += n;
1682 }
1683
1684 /* Do the copy */
1685 s->src_cur = 0;
1686 s->src_cur_offset = 0;
1687 s->sector_next_status = 0;
1688
1689 sector_num = 0;
1690 allocated_done = 0;
1691
1692 while (sector_num < s->total_sectors) {
1693 n = convert_iteration_sectors(s, sector_num);
1694 if (n < 0) {
1695 ret = n;
1696 goto fail;
1697 }
1698 if (s->status == BLK_DATA || (!s->min_sparse && s->status == BLK_ZERO))
1699 {
1700 allocated_done += n;
1701 qemu_progress_print(100.0 * allocated_done / s->allocated_sectors,
1702 0);
1703 }
1704
1705 if (s->status == BLK_DATA) {
1706 ret = convert_read(s, sector_num, n, buf);
1707 if (ret < 0) {
1708 error_report("error while reading sector %" PRId64
1709 ": %s", sector_num, strerror(-ret));
1710 goto fail;
1711 }
1712 } else if (!s->min_sparse && s->status == BLK_ZERO) {
1713 n = MIN(n, s->buf_sectors);
1714 memset(buf, 0, n * BDRV_SECTOR_SIZE);
1715 s->status = BLK_DATA;
1716 }
1717
1718 ret = convert_write(s, sector_num, n, buf);
1719 if (ret < 0) {
1720 error_report("error while writing sector %" PRId64
1721 ": %s", sector_num, strerror(-ret));
1722 goto fail;
1723 }
1724
1725 sector_num += n;
1726 }
1727
1728 if (s->compressed) {
1729 /* signal EOF to align */
1730 ret = blk_write_compressed(s->target, 0, NULL, 0);
1731 if (ret < 0) {
1732 goto fail;
1733 }
1734 }
1735
1736 ret = 0;
1737 fail:
1738 qemu_vfree(buf);
1739 return ret;
1740 }
1741
1742 static int img_convert(int argc, char **argv)
1743 {
1744 int c, bs_n, bs_i, compress, cluster_sectors, skip_create;
1745 int64_t ret = 0;
1746 int progress = 0, flags, src_flags;
1747 bool writethrough, src_writethrough;
1748 const char *fmt, *out_fmt, *cache, *src_cache, *out_baseimg, *out_filename;
1749 BlockDriver *drv, *proto_drv;
1750 BlockBackend **blk = NULL, *out_blk = NULL;
1751 BlockDriverState **bs = NULL, *out_bs = NULL;
1752 int64_t total_sectors;
1753 int64_t *bs_sectors = NULL;
1754 size_t bufsectors = IO_BUF_SIZE / BDRV_SECTOR_SIZE;
1755 BlockDriverInfo bdi;
1756 QemuOpts *opts = NULL;
1757 QemuOptsList *create_opts = NULL;
1758 const char *out_baseimg_param;
1759 char *options = NULL;
1760 const char *snapshot_name = NULL;
1761 int min_sparse = 8; /* Need at least 4k of zeros for sparse detection */
1762 bool quiet = false;
1763 Error *local_err = NULL;
1764 QemuOpts *sn_opts = NULL;
1765 ImgConvertState state;
1766 bool image_opts = false;
1767
1768 fmt = NULL;
1769 out_fmt = "raw";
1770 cache = "unsafe";
1771 src_cache = BDRV_DEFAULT_CACHE;
1772 out_baseimg = NULL;
1773 compress = 0;
1774 skip_create = 0;
1775 for(;;) {
1776 static const struct option long_options[] = {
1777 {"help", no_argument, 0, 'h'},
1778 {"object", required_argument, 0, OPTION_OBJECT},
1779 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
1780 {0, 0, 0, 0}
1781 };
1782 c = getopt_long(argc, argv, "hf:O:B:ce6o:s:l:S:pt:T:qn",
1783 long_options, NULL);
1784 if (c == -1) {
1785 break;
1786 }
1787 switch(c) {
1788 case '?':
1789 case 'h':
1790 help();
1791 break;
1792 case 'f':
1793 fmt = optarg;
1794 break;
1795 case 'O':
1796 out_fmt = optarg;
1797 break;
1798 case 'B':
1799 out_baseimg = optarg;
1800 break;
1801 case 'c':
1802 compress = 1;
1803 break;
1804 case 'e':
1805 error_report("option -e is deprecated, please use \'-o "
1806 "encryption\' instead!");
1807 ret = -1;
1808 goto fail_getopt;
1809 case '6':
1810 error_report("option -6 is deprecated, please use \'-o "
1811 "compat6\' instead!");
1812 ret = -1;
1813 goto fail_getopt;
1814 case 'o':
1815 if (!is_valid_option_list(optarg)) {
1816 error_report("Invalid option list: %s", optarg);
1817 ret = -1;
1818 goto fail_getopt;
1819 }
1820 if (!options) {
1821 options = g_strdup(optarg);
1822 } else {
1823 char *old_options = options;
1824 options = g_strdup_printf("%s,%s", options, optarg);
1825 g_free(old_options);
1826 }
1827 break;
1828 case 's':
1829 snapshot_name = optarg;
1830 break;
1831 case 'l':
1832 if (strstart(optarg, SNAPSHOT_OPT_BASE, NULL)) {
1833 sn_opts = qemu_opts_parse_noisily(&internal_snapshot_opts,
1834 optarg, false);
1835 if (!sn_opts) {
1836 error_report("Failed in parsing snapshot param '%s'",
1837 optarg);
1838 ret = -1;
1839 goto fail_getopt;
1840 }
1841 } else {
1842 snapshot_name = optarg;
1843 }
1844 break;
1845 case 'S':
1846 {
1847 int64_t sval;
1848 char *end;
1849 sval = qemu_strtosz_suffix(optarg, &end, QEMU_STRTOSZ_DEFSUFFIX_B);
1850 if (sval < 0 || *end) {
1851 error_report("Invalid minimum zero buffer size for sparse output specified");
1852 ret = -1;
1853 goto fail_getopt;
1854 }
1855
1856 min_sparse = sval / BDRV_SECTOR_SIZE;
1857 break;
1858 }
1859 case 'p':
1860 progress = 1;
1861 break;
1862 case 't':
1863 cache = optarg;
1864 break;
1865 case 'T':
1866 src_cache = optarg;
1867 break;
1868 case 'q':
1869 quiet = true;
1870 break;
1871 case 'n':
1872 skip_create = 1;
1873 break;
1874 case OPTION_OBJECT:
1875 opts = qemu_opts_parse_noisily(&qemu_object_opts,
1876 optarg, true);
1877 if (!opts) {
1878 goto fail_getopt;
1879 }
1880 break;
1881 case OPTION_IMAGE_OPTS:
1882 image_opts = true;
1883 break;
1884 }
1885 }
1886
1887 if (qemu_opts_foreach(&qemu_object_opts,
1888 user_creatable_add_opts_foreach,
1889 NULL, NULL)) {
1890 goto fail_getopt;
1891 }
1892
1893 /* Initialize before goto out */
1894 if (quiet) {
1895 progress = 0;
1896 }
1897 qemu_progress_init(progress, 1.0);
1898
1899 bs_n = argc - optind - 1;
1900 out_filename = bs_n >= 1 ? argv[argc - 1] : NULL;
1901
1902 if (options && has_help_option(options)) {
1903 ret = print_block_option_help(out_filename, out_fmt);
1904 goto out;
1905 }
1906
1907 if (bs_n < 1) {
1908 error_exit("Must specify image file name");
1909 }
1910
1911
1912 if (bs_n > 1 && out_baseimg) {
1913 error_report("-B makes no sense when concatenating multiple input "
1914 "images");
1915 ret = -1;
1916 goto out;
1917 }
1918
1919 src_flags = 0;
1920 ret = bdrv_parse_cache_mode(src_cache, &src_flags, &src_writethrough);
1921 if (ret < 0) {
1922 error_report("Invalid source cache option: %s", src_cache);
1923 goto out;
1924 }
1925
1926 qemu_progress_print(0, 100);
1927
1928 blk = g_new0(BlockBackend *, bs_n);
1929 bs = g_new0(BlockDriverState *, bs_n);
1930 bs_sectors = g_new(int64_t, bs_n);
1931
1932 total_sectors = 0;
1933 for (bs_i = 0; bs_i < bs_n; bs_i++) {
1934 blk[bs_i] = img_open(image_opts, argv[optind + bs_i],
1935 fmt, src_flags, src_writethrough, quiet);
1936 if (!blk[bs_i]) {
1937 ret = -1;
1938 goto out;
1939 }
1940 bs[bs_i] = blk_bs(blk[bs_i]);
1941 bs_sectors[bs_i] = blk_nb_sectors(blk[bs_i]);
1942 if (bs_sectors[bs_i] < 0) {
1943 error_report("Could not get size of %s: %s",
1944 argv[optind + bs_i], strerror(-bs_sectors[bs_i]));
1945 ret = -1;
1946 goto out;
1947 }
1948 total_sectors += bs_sectors[bs_i];
1949 }
1950
1951 if (sn_opts) {
1952 ret = bdrv_snapshot_load_tmp(bs[0],
1953 qemu_opt_get(sn_opts, SNAPSHOT_OPT_ID),
1954 qemu_opt_get(sn_opts, SNAPSHOT_OPT_NAME),
1955 &local_err);
1956 } else if (snapshot_name != NULL) {
1957 if (bs_n > 1) {
1958 error_report("No support for concatenating multiple snapshot");
1959 ret = -1;
1960 goto out;
1961 }
1962
1963 bdrv_snapshot_load_tmp_by_id_or_name(bs[0], snapshot_name, &local_err);
1964 }
1965 if (local_err) {
1966 error_reportf_err(local_err, "Failed to load snapshot: ");
1967 ret = -1;
1968 goto out;
1969 }
1970
1971 /* Find driver and parse its options */
1972 drv = bdrv_find_format(out_fmt);
1973 if (!drv) {
1974 error_report("Unknown file format '%s'", out_fmt);
1975 ret = -1;
1976 goto out;
1977 }
1978
1979 proto_drv = bdrv_find_protocol(out_filename, true, &local_err);
1980 if (!proto_drv) {
1981 error_report_err(local_err);
1982 ret = -1;
1983 goto out;
1984 }
1985
1986 if (!skip_create) {
1987 if (!drv->create_opts) {
1988 error_report("Format driver '%s' does not support image creation",
1989 drv->format_name);
1990 ret = -1;
1991 goto out;
1992 }
1993
1994 if (!proto_drv->create_opts) {
1995 error_report("Protocol driver '%s' does not support image creation",
1996 proto_drv->format_name);
1997 ret = -1;
1998 goto out;
1999 }
2000
2001 create_opts = qemu_opts_append(create_opts, drv->create_opts);
2002 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
2003
2004 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
2005 if (options) {
2006 qemu_opts_do_parse(opts, options, NULL, &local_err);
2007 if (local_err) {
2008 error_report_err(local_err);
2009 ret = -1;
2010 goto out;
2011 }
2012 }
2013
2014 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_sectors * 512,
2015 &error_abort);
2016 ret = add_old_style_options(out_fmt, opts, out_baseimg, NULL);
2017 if (ret < 0) {
2018 goto out;
2019 }
2020 }
2021
2022 /* Get backing file name if -o backing_file was used */
2023 out_baseimg_param = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
2024 if (out_baseimg_param) {
2025 out_baseimg = out_baseimg_param;
2026 }
2027
2028 /* Check if compression is supported */
2029 if (compress) {
2030 bool encryption =
2031 qemu_opt_get_bool(opts, BLOCK_OPT_ENCRYPT, false);
2032 const char *preallocation =
2033 qemu_opt_get(opts, BLOCK_OPT_PREALLOC);
2034
2035 if (!drv->bdrv_write_compressed) {
2036 error_report("Compression not supported for this file format");
2037 ret = -1;
2038 goto out;
2039 }
2040
2041 if (encryption) {
2042 error_report("Compression and encryption not supported at "
2043 "the same time");
2044 ret = -1;
2045 goto out;
2046 }
2047
2048 if (preallocation
2049 && strcmp(preallocation, "off"))
2050 {
2051 error_report("Compression and preallocation not supported at "
2052 "the same time");
2053 ret = -1;
2054 goto out;
2055 }
2056 }
2057
2058 if (!skip_create) {
2059 /* Create the new image */
2060 ret = bdrv_create(drv, out_filename, opts, &local_err);
2061 if (ret < 0) {
2062 error_reportf_err(local_err, "%s: error while converting %s: ",
2063 out_filename, out_fmt);
2064 goto out;
2065 }
2066 }
2067
2068 flags = min_sparse ? (BDRV_O_RDWR | BDRV_O_UNMAP) : BDRV_O_RDWR;
2069 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
2070 if (ret < 0) {
2071 error_report("Invalid cache option: %s", cache);
2072 goto out;
2073 }
2074
2075 /* XXX we should allow --image-opts to trigger use of
2076 * img_open() here, but then we have trouble with
2077 * the bdrv_create() call which takes different params.
2078 * Not critical right now, so fix can wait...
2079 */
2080 out_blk = img_open_file(out_filename, out_fmt, flags, writethrough, quiet);
2081 if (!out_blk) {
2082 ret = -1;
2083 goto out;
2084 }
2085 out_bs = blk_bs(out_blk);
2086
2087 /* increase bufsectors from the default 4096 (2M) if opt_transfer
2088 * or discard_alignment of the out_bs is greater. Limit to 32768 (16MB)
2089 * as maximum. */
2090 bufsectors = MIN(32768,
2091 MAX(bufsectors,
2092 MAX(out_bs->bl.opt_transfer >> BDRV_SECTOR_BITS,
2093 out_bs->bl.pdiscard_alignment >>
2094 BDRV_SECTOR_BITS)));
2095
2096 if (skip_create) {
2097 int64_t output_sectors = blk_nb_sectors(out_blk);
2098 if (output_sectors < 0) {
2099 error_report("unable to get output image length: %s",
2100 strerror(-output_sectors));
2101 ret = -1;
2102 goto out;
2103 } else if (output_sectors < total_sectors) {
2104 error_report("output file is smaller than input file");
2105 ret = -1;
2106 goto out;
2107 }
2108 }
2109
2110 cluster_sectors = 0;
2111 ret = bdrv_get_info(out_bs, &bdi);
2112 if (ret < 0) {
2113 if (compress) {
2114 error_report("could not get block driver info");
2115 goto out;
2116 }
2117 } else {
2118 compress = compress || bdi.needs_compressed_writes;
2119 cluster_sectors = bdi.cluster_size / BDRV_SECTOR_SIZE;
2120 }
2121
2122 state = (ImgConvertState) {
2123 .src = blk,
2124 .src_sectors = bs_sectors,
2125 .src_num = bs_n,
2126 .total_sectors = total_sectors,
2127 .target = out_blk,
2128 .compressed = compress,
2129 .target_has_backing = (bool) out_baseimg,
2130 .min_sparse = min_sparse,
2131 .cluster_sectors = cluster_sectors,
2132 .buf_sectors = bufsectors,
2133 };
2134 ret = convert_do_copy(&state);
2135
2136 out:
2137 if (!ret) {
2138 qemu_progress_print(100, 0);
2139 }
2140 qemu_progress_end();
2141 qemu_opts_del(opts);
2142 qemu_opts_free(create_opts);
2143 qemu_opts_del(sn_opts);
2144 blk_unref(out_blk);
2145 g_free(bs);
2146 if (blk) {
2147 for (bs_i = 0; bs_i < bs_n; bs_i++) {
2148 blk_unref(blk[bs_i]);
2149 }
2150 g_free(blk);
2151 }
2152 g_free(bs_sectors);
2153 fail_getopt:
2154 g_free(options);
2155
2156 if (ret) {
2157 return 1;
2158 }
2159 return 0;
2160 }
2161
2162
2163 static void dump_snapshots(BlockDriverState *bs)
2164 {
2165 QEMUSnapshotInfo *sn_tab, *sn;
2166 int nb_sns, i;
2167
2168 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
2169 if (nb_sns <= 0)
2170 return;
2171 printf("Snapshot list:\n");
2172 bdrv_snapshot_dump(fprintf, stdout, NULL);
2173 printf("\n");
2174 for(i = 0; i < nb_sns; i++) {
2175 sn = &sn_tab[i];
2176 bdrv_snapshot_dump(fprintf, stdout, sn);
2177 printf("\n");
2178 }
2179 g_free(sn_tab);
2180 }
2181
2182 static void dump_json_image_info_list(ImageInfoList *list)
2183 {
2184 QString *str;
2185 QObject *obj;
2186 Visitor *v = qmp_output_visitor_new(&obj);
2187
2188 visit_type_ImageInfoList(v, NULL, &list, &error_abort);
2189 visit_complete(v, &obj);
2190 str = qobject_to_json_pretty(obj);
2191 assert(str != NULL);
2192 printf("%s\n", qstring_get_str(str));
2193 qobject_decref(obj);
2194 visit_free(v);
2195 QDECREF(str);
2196 }
2197
2198 static void dump_json_image_info(ImageInfo *info)
2199 {
2200 QString *str;
2201 QObject *obj;
2202 Visitor *v = qmp_output_visitor_new(&obj);
2203
2204 visit_type_ImageInfo(v, NULL, &info, &error_abort);
2205 visit_complete(v, &obj);
2206 str = qobject_to_json_pretty(obj);
2207 assert(str != NULL);
2208 printf("%s\n", qstring_get_str(str));
2209 qobject_decref(obj);
2210 visit_free(v);
2211 QDECREF(str);
2212 }
2213
2214 static void dump_human_image_info_list(ImageInfoList *list)
2215 {
2216 ImageInfoList *elem;
2217 bool delim = false;
2218
2219 for (elem = list; elem; elem = elem->next) {
2220 if (delim) {
2221 printf("\n");
2222 }
2223 delim = true;
2224
2225 bdrv_image_info_dump(fprintf, stdout, elem->value);
2226 }
2227 }
2228
2229 static gboolean str_equal_func(gconstpointer a, gconstpointer b)
2230 {
2231 return strcmp(a, b) == 0;
2232 }
2233
2234 /**
2235 * Open an image file chain and return an ImageInfoList
2236 *
2237 * @filename: topmost image filename
2238 * @fmt: topmost image format (may be NULL to autodetect)
2239 * @chain: true - enumerate entire backing file chain
2240 * false - only topmost image file
2241 *
2242 * Returns a list of ImageInfo objects or NULL if there was an error opening an
2243 * image file. If there was an error a message will have been printed to
2244 * stderr.
2245 */
2246 static ImageInfoList *collect_image_info_list(bool image_opts,
2247 const char *filename,
2248 const char *fmt,
2249 bool chain)
2250 {
2251 ImageInfoList *head = NULL;
2252 ImageInfoList **last = &head;
2253 GHashTable *filenames;
2254 Error *err = NULL;
2255
2256 filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL);
2257
2258 while (filename) {
2259 BlockBackend *blk;
2260 BlockDriverState *bs;
2261 ImageInfo *info;
2262 ImageInfoList *elem;
2263
2264 if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) {
2265 error_report("Backing file '%s' creates an infinite loop.",
2266 filename);
2267 goto err;
2268 }
2269 g_hash_table_insert(filenames, (gpointer)filename, NULL);
2270
2271 blk = img_open(image_opts, filename, fmt,
2272 BDRV_O_NO_BACKING | BDRV_O_NO_IO, false, false);
2273 if (!blk) {
2274 goto err;
2275 }
2276 bs = blk_bs(blk);
2277
2278 bdrv_query_image_info(bs, &info, &err);
2279 if (err) {
2280 error_report_err(err);
2281 blk_unref(blk);
2282 goto err;
2283 }
2284
2285 elem = g_new0(ImageInfoList, 1);
2286 elem->value = info;
2287 *last = elem;
2288 last = &elem->next;
2289
2290 blk_unref(blk);
2291
2292 filename = fmt = NULL;
2293 if (chain) {
2294 if (info->has_full_backing_filename) {
2295 filename = info->full_backing_filename;
2296 } else if (info->has_backing_filename) {
2297 error_report("Could not determine absolute backing filename,"
2298 " but backing filename '%s' present",
2299 info->backing_filename);
2300 goto err;
2301 }
2302 if (info->has_backing_filename_format) {
2303 fmt = info->backing_filename_format;
2304 }
2305 }
2306 }
2307 g_hash_table_destroy(filenames);
2308 return head;
2309
2310 err:
2311 qapi_free_ImageInfoList(head);
2312 g_hash_table_destroy(filenames);
2313 return NULL;
2314 }
2315
2316 static int img_info(int argc, char **argv)
2317 {
2318 int c;
2319 OutputFormat output_format = OFORMAT_HUMAN;
2320 bool chain = false;
2321 const char *filename, *fmt, *output;
2322 ImageInfoList *list;
2323 bool image_opts = false;
2324
2325 fmt = NULL;
2326 output = NULL;
2327 for(;;) {
2328 int option_index = 0;
2329 static const struct option long_options[] = {
2330 {"help", no_argument, 0, 'h'},
2331 {"format", required_argument, 0, 'f'},
2332 {"output", required_argument, 0, OPTION_OUTPUT},
2333 {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN},
2334 {"object", required_argument, 0, OPTION_OBJECT},
2335 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
2336 {0, 0, 0, 0}
2337 };
2338 c = getopt_long(argc, argv, "f:h",
2339 long_options, &option_index);
2340 if (c == -1) {
2341 break;
2342 }
2343 switch(c) {
2344 case '?':
2345 case 'h':
2346 help();
2347 break;
2348 case 'f':
2349 fmt = optarg;
2350 break;
2351 case OPTION_OUTPUT:
2352 output = optarg;
2353 break;
2354 case OPTION_BACKING_CHAIN:
2355 chain = true;
2356 break;
2357 case OPTION_OBJECT: {
2358 QemuOpts *opts;
2359 opts = qemu_opts_parse_noisily(&qemu_object_opts,
2360 optarg, true);
2361 if (!opts) {
2362 return 1;
2363 }
2364 } break;
2365 case OPTION_IMAGE_OPTS:
2366 image_opts = true;
2367 break;
2368 }
2369 }
2370 if (optind != argc - 1) {
2371 error_exit("Expecting one image file name");
2372 }
2373 filename = argv[optind++];
2374
2375 if (output && !strcmp(output, "json")) {
2376 output_format = OFORMAT_JSON;
2377 } else if (output && !strcmp(output, "human")) {
2378 output_format = OFORMAT_HUMAN;
2379 } else if (output) {
2380 error_report("--output must be used with human or json as argument.");
2381 return 1;
2382 }
2383
2384 if (qemu_opts_foreach(&qemu_object_opts,
2385 user_creatable_add_opts_foreach,
2386 NULL, NULL)) {
2387 return 1;
2388 }
2389
2390 list = collect_image_info_list(image_opts, filename, fmt, chain);
2391 if (!list) {
2392 return 1;
2393 }
2394
2395 switch (output_format) {
2396 case OFORMAT_HUMAN:
2397 dump_human_image_info_list(list);
2398 break;
2399 case OFORMAT_JSON:
2400 if (chain) {
2401 dump_json_image_info_list(list);
2402 } else {
2403 dump_json_image_info(list->value);
2404 }
2405 break;
2406 }
2407
2408 qapi_free_ImageInfoList(list);
2409 return 0;
2410 }
2411
2412 static void dump_map_entry(OutputFormat output_format, MapEntry *e,
2413 MapEntry *next)
2414 {
2415 switch (output_format) {
2416 case OFORMAT_HUMAN:
2417 if (e->data && !e->has_offset) {
2418 error_report("File contains external, encrypted or compressed clusters.");
2419 exit(1);
2420 }
2421 if (e->data && !e->zero) {
2422 printf("%#-16"PRIx64"%#-16"PRIx64"%#-16"PRIx64"%s\n",
2423 e->start, e->length,
2424 e->has_offset ? e->offset : 0,
2425 e->has_filename ? e->filename : "");
2426 }
2427 /* This format ignores the distinction between 0, ZERO and ZERO|DATA.
2428 * Modify the flags here to allow more coalescing.
2429 */
2430 if (next && (!next->data || next->zero)) {
2431 next->data = false;
2432 next->zero = true;
2433 }
2434 break;
2435 case OFORMAT_JSON:
2436 printf("%s{ \"start\": %"PRId64", \"length\": %"PRId64","
2437 " \"depth\": %"PRId64", \"zero\": %s, \"data\": %s",
2438 (e->start == 0 ? "[" : ",\n"),
2439 e->start, e->length, e->depth,
2440 e->zero ? "true" : "false",
2441 e->data ? "true" : "false");
2442 if (e->has_offset) {
2443 printf(", \"offset\": %"PRId64"", e->offset);
2444 }
2445 putchar('}');
2446
2447 if (!next) {
2448 printf("]\n");
2449 }
2450 break;
2451 }
2452 }
2453
2454 static int get_block_status(BlockDriverState *bs, int64_t sector_num,
2455 int nb_sectors, MapEntry *e)
2456 {
2457 int64_t ret;
2458 int depth;
2459 BlockDriverState *file;
2460 bool has_offset;
2461
2462 /* As an optimization, we could cache the current range of unallocated
2463 * clusters in each file of the chain, and avoid querying the same
2464 * range repeatedly.
2465 */
2466
2467 depth = 0;
2468 for (;;) {
2469 ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &nb_sectors,
2470 &file);
2471 if (ret < 0) {
2472 return ret;
2473 }
2474 assert(nb_sectors);
2475 if (ret & (BDRV_BLOCK_ZERO|BDRV_BLOCK_DATA)) {
2476 break;
2477 }
2478 bs = backing_bs(bs);
2479 if (bs == NULL) {
2480 ret = 0;
2481 break;
2482 }
2483
2484 depth++;
2485 }
2486
2487 has_offset = !!(ret & BDRV_BLOCK_OFFSET_VALID);
2488
2489 *e = (MapEntry) {
2490 .start = sector_num * BDRV_SECTOR_SIZE,
2491 .length = nb_sectors * BDRV_SECTOR_SIZE,
2492 .data = !!(ret & BDRV_BLOCK_DATA),
2493 .zero = !!(ret & BDRV_BLOCK_ZERO),
2494 .offset = ret & BDRV_BLOCK_OFFSET_MASK,
2495 .has_offset = has_offset,
2496 .depth = depth,
2497 .has_filename = file && has_offset,
2498 .filename = file && has_offset ? file->filename : NULL,
2499 };
2500
2501 return 0;
2502 }
2503
2504 static inline bool entry_mergeable(const MapEntry *curr, const MapEntry *next)
2505 {
2506 if (curr->length == 0) {
2507 return false;
2508 }
2509 if (curr->zero != next->zero ||
2510 curr->data != next->data ||
2511 curr->depth != next->depth ||
2512 curr->has_filename != next->has_filename ||
2513 curr->has_offset != next->has_offset) {
2514 return false;
2515 }
2516 if (curr->has_filename && strcmp(curr->filename, next->filename)) {
2517 return false;
2518 }
2519 if (curr->has_offset && curr->offset + curr->length != next->offset) {
2520 return false;
2521 }
2522 return true;
2523 }
2524
2525 static int img_map(int argc, char **argv)
2526 {
2527 int c;
2528 OutputFormat output_format = OFORMAT_HUMAN;
2529 BlockBackend *blk;
2530 BlockDriverState *bs;
2531 const char *filename, *fmt, *output;
2532 int64_t length;
2533 MapEntry curr = { .length = 0 }, next;
2534 int ret = 0;
2535 bool image_opts = false;
2536
2537 fmt = NULL;
2538 output = NULL;
2539 for (;;) {
2540 int option_index = 0;
2541 static const struct option long_options[] = {
2542 {"help", no_argument, 0, 'h'},
2543 {"format", required_argument, 0, 'f'},
2544 {"output", required_argument, 0, OPTION_OUTPUT},
2545 {"object", required_argument, 0, OPTION_OBJECT},
2546 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
2547 {0, 0, 0, 0}
2548 };
2549 c = getopt_long(argc, argv, "f:h",
2550 long_options, &option_index);
2551 if (c == -1) {
2552 break;
2553 }
2554 switch (c) {
2555 case '?':
2556 case 'h':
2557 help();
2558 break;
2559 case 'f':
2560 fmt = optarg;
2561 break;
2562 case OPTION_OUTPUT:
2563 output = optarg;
2564 break;
2565 case OPTION_OBJECT: {
2566 QemuOpts *opts;
2567 opts = qemu_opts_parse_noisily(&qemu_object_opts,
2568 optarg, true);
2569 if (!opts) {
2570 return 1;
2571 }
2572 } break;
2573 case OPTION_IMAGE_OPTS:
2574 image_opts = true;
2575 break;
2576 }
2577 }
2578 if (optind != argc - 1) {
2579 error_exit("Expecting one image file name");
2580 }
2581 filename = argv[optind];
2582
2583 if (output && !strcmp(output, "json")) {
2584 output_format = OFORMAT_JSON;
2585 } else if (output && !strcmp(output, "human")) {
2586 output_format = OFORMAT_HUMAN;
2587 } else if (output) {
2588 error_report("--output must be used with human or json as argument.");
2589 return 1;
2590 }
2591
2592 if (qemu_opts_foreach(&qemu_object_opts,
2593 user_creatable_add_opts_foreach,
2594 NULL, NULL)) {
2595 return 1;
2596 }
2597
2598 blk = img_open(image_opts, filename, fmt, 0, false, false);
2599 if (!blk) {
2600 return 1;
2601 }
2602 bs = blk_bs(blk);
2603
2604 if (output_format == OFORMAT_HUMAN) {
2605 printf("%-16s%-16s%-16s%s\n", "Offset", "Length", "Mapped to", "File");
2606 }
2607
2608 length = blk_getlength(blk);
2609 while (curr.start + curr.length < length) {
2610 int64_t nsectors_left;
2611 int64_t sector_num;
2612 int n;
2613
2614 sector_num = (curr.start + curr.length) >> BDRV_SECTOR_BITS;
2615
2616 /* Probe up to 1 GiB at a time. */
2617 nsectors_left = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE) - sector_num;
2618 n = MIN(1 << (30 - BDRV_SECTOR_BITS), nsectors_left);
2619 ret = get_block_status(bs, sector_num, n, &next);
2620
2621 if (ret < 0) {
2622 error_report("Could not read file metadata: %s", strerror(-ret));
2623 goto out;
2624 }
2625
2626 if (entry_mergeable(&curr, &next)) {
2627 curr.length += next.length;
2628 continue;
2629 }
2630
2631 if (curr.length > 0) {
2632 dump_map_entry(output_format, &curr, &next);
2633 }
2634 curr = next;
2635 }
2636
2637 dump_map_entry(output_format, &curr, NULL);
2638
2639 out:
2640 blk_unref(blk);
2641 return ret < 0;
2642 }
2643
2644 #define SNAPSHOT_LIST 1
2645 #define SNAPSHOT_CREATE 2
2646 #define SNAPSHOT_APPLY 3
2647 #define SNAPSHOT_DELETE 4
2648
2649 static int img_snapshot(int argc, char **argv)
2650 {
2651 BlockBackend *blk;
2652 BlockDriverState *bs;
2653 QEMUSnapshotInfo sn;
2654 char *filename, *snapshot_name = NULL;
2655 int c, ret = 0, bdrv_oflags;
2656 int action = 0;
2657 qemu_timeval tv;
2658 bool quiet = false;
2659 Error *err = NULL;
2660 bool image_opts = false;
2661
2662 bdrv_oflags = BDRV_O_RDWR;
2663 /* Parse commandline parameters */
2664 for(;;) {
2665 static const struct option long_options[] = {
2666 {"help", no_argument, 0, 'h'},
2667 {"object", required_argument, 0, OPTION_OBJECT},
2668 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
2669 {0, 0, 0, 0}
2670 };
2671 c = getopt_long(argc, argv, "la:c:d:hq",
2672 long_options, NULL);
2673 if (c == -1) {
2674 break;
2675 }
2676 switch(c) {
2677 case '?':
2678 case 'h':
2679 help();
2680 return 0;
2681 case 'l':
2682 if (action) {
2683 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2684 return 0;
2685 }
2686 action = SNAPSHOT_LIST;
2687 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
2688 break;
2689 case 'a':
2690 if (action) {
2691 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2692 return 0;
2693 }
2694 action = SNAPSHOT_APPLY;
2695 snapshot_name = optarg;
2696 break;
2697 case 'c':
2698 if (action) {
2699 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2700 return 0;
2701 }
2702 action = SNAPSHOT_CREATE;
2703 snapshot_name = optarg;
2704 break;
2705 case 'd':
2706 if (action) {
2707 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2708 return 0;
2709 }
2710 action = SNAPSHOT_DELETE;
2711 snapshot_name = optarg;
2712 break;
2713 case 'q':
2714 quiet = true;
2715 break;
2716 case OPTION_OBJECT: {
2717 QemuOpts *opts;
2718 opts = qemu_opts_parse_noisily(&qemu_object_opts,
2719 optarg, true);
2720 if (!opts) {
2721 return 1;
2722 }
2723 } break;
2724 case OPTION_IMAGE_OPTS:
2725 image_opts = true;
2726 break;
2727 }
2728 }
2729
2730 if (optind != argc - 1) {
2731 error_exit("Expecting one image file name");
2732 }
2733 filename = argv[optind++];
2734
2735 if (qemu_opts_foreach(&qemu_object_opts,
2736 user_creatable_add_opts_foreach,
2737 NULL, NULL)) {
2738 return 1;
2739 }
2740
2741 /* Open the image */
2742 blk = img_open(image_opts, filename, NULL, bdrv_oflags, false, quiet);
2743 if (!blk) {
2744 return 1;
2745 }
2746 bs = blk_bs(blk);
2747
2748 /* Perform the requested action */
2749 switch(action) {
2750 case SNAPSHOT_LIST:
2751 dump_snapshots(bs);
2752 break;
2753
2754 case SNAPSHOT_CREATE:
2755 memset(&sn, 0, sizeof(sn));
2756 pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
2757
2758 qemu_gettimeofday(&tv);
2759 sn.date_sec = tv.tv_sec;
2760 sn.date_nsec = tv.tv_usec * 1000;
2761
2762 ret = bdrv_snapshot_create(bs, &sn);
2763 if (ret) {
2764 error_report("Could not create snapshot '%s': %d (%s)",
2765 snapshot_name, ret, strerror(-ret));
2766 }
2767 break;
2768
2769 case SNAPSHOT_APPLY:
2770 ret = bdrv_snapshot_goto(bs, snapshot_name);
2771 if (ret) {
2772 error_report("Could not apply snapshot '%s': %d (%s)",
2773 snapshot_name, ret, strerror(-ret));
2774 }
2775 break;
2776
2777 case SNAPSHOT_DELETE:
2778 bdrv_snapshot_delete_by_id_or_name(bs, snapshot_name, &err);
2779 if (err) {
2780 error_reportf_err(err, "Could not delete snapshot '%s': ",
2781 snapshot_name);
2782 ret = 1;
2783 }
2784 break;
2785 }
2786
2787 /* Cleanup */
2788 blk_unref(blk);
2789 if (ret) {
2790 return 1;
2791 }
2792 return 0;
2793 }
2794
2795 static int img_rebase(int argc, char **argv)
2796 {
2797 BlockBackend *blk = NULL, *blk_old_backing = NULL, *blk_new_backing = NULL;
2798 uint8_t *buf_old = NULL;
2799 uint8_t *buf_new = NULL;
2800 BlockDriverState *bs = NULL;
2801 char *filename;
2802 const char *fmt, *cache, *src_cache, *out_basefmt, *out_baseimg;
2803 int c, flags, src_flags, ret;
2804 bool writethrough, src_writethrough;
2805 int unsafe = 0;
2806 int progress = 0;
2807 bool quiet = false;
2808 Error *local_err = NULL;
2809 bool image_opts = false;
2810
2811 /* Parse commandline parameters */
2812 fmt = NULL;
2813 cache = BDRV_DEFAULT_CACHE;
2814 src_cache = BDRV_DEFAULT_CACHE;
2815 out_baseimg = NULL;
2816 out_basefmt = NULL;
2817 for(;;) {
2818 static const struct option long_options[] = {
2819 {"help", no_argument, 0, 'h'},
2820 {"object", required_argument, 0, OPTION_OBJECT},
2821 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
2822 {0, 0, 0, 0}
2823 };
2824 c = getopt_long(argc, argv, "hf:F:b:upt:T:q",
2825 long_options, NULL);
2826 if (c == -1) {
2827 break;
2828 }
2829 switch(c) {
2830 case '?':
2831 case 'h':
2832 help();
2833 return 0;
2834 case 'f':
2835 fmt = optarg;
2836 break;
2837 case 'F':
2838 out_basefmt = optarg;
2839 break;
2840 case 'b':
2841 out_baseimg = optarg;
2842 break;
2843 case 'u':
2844 unsafe = 1;
2845 break;
2846 case 'p':
2847 progress = 1;
2848 break;
2849 case 't':
2850 cache = optarg;
2851 break;
2852 case 'T':
2853 src_cache = optarg;
2854 break;
2855 case 'q':
2856 quiet = true;
2857 break;
2858 case OPTION_OBJECT: {
2859 QemuOpts *opts;
2860 opts = qemu_opts_parse_noisily(&qemu_object_opts,
2861 optarg, true);
2862 if (!opts) {
2863 return 1;
2864 }
2865 } break;
2866 case OPTION_IMAGE_OPTS:
2867 image_opts = true;
2868 break;
2869 }
2870 }
2871
2872 if (quiet) {
2873 progress = 0;
2874 }
2875
2876 if (optind != argc - 1) {
2877 error_exit("Expecting one image file name");
2878 }
2879 if (!unsafe && !out_baseimg) {
2880 error_exit("Must specify backing file (-b) or use unsafe mode (-u)");
2881 }
2882 filename = argv[optind++];
2883
2884 if (qemu_opts_foreach(&qemu_object_opts,
2885 user_creatable_add_opts_foreach,
2886 NULL, NULL)) {
2887 return 1;
2888 }
2889
2890 qemu_progress_init(progress, 2.0);
2891 qemu_progress_print(0, 100);
2892
2893 flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
2894 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
2895 if (ret < 0) {
2896 error_report("Invalid cache option: %s", cache);
2897 goto out;
2898 }
2899
2900 src_flags = 0;
2901 ret = bdrv_parse_cache_mode(src_cache, &src_flags, &src_writethrough);
2902 if (ret < 0) {
2903 error_report("Invalid source cache option: %s", src_cache);
2904 goto out;
2905 }
2906
2907 /* The source files are opened read-only, don't care about WCE */
2908 assert((src_flags & BDRV_O_RDWR) == 0);
2909 (void) src_writethrough;
2910
2911 /*
2912 * Open the images.
2913 *
2914 * Ignore the old backing file for unsafe rebase in case we want to correct
2915 * the reference to a renamed or moved backing file.
2916 */
2917 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet);
2918 if (!blk) {
2919 ret = -1;
2920 goto out;
2921 }
2922 bs = blk_bs(blk);
2923
2924 if (out_basefmt != NULL) {
2925 if (bdrv_find_format(out_basefmt) == NULL) {
2926 error_report("Invalid format name: '%s'", out_basefmt);
2927 ret = -1;
2928 goto out;
2929 }
2930 }
2931
2932 /* For safe rebasing we need to compare old and new backing file */
2933 if (!unsafe) {
2934 char backing_name[PATH_MAX];
2935 QDict *options = NULL;
2936
2937 if (bs->backing_format[0] != '\0') {
2938 options = qdict_new();
2939 qdict_put(options, "driver", qstring_from_str(bs->backing_format));
2940 }
2941
2942 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
2943 blk_old_backing = blk_new_open(backing_name, NULL,
2944 options, src_flags, &local_err);
2945 if (!blk_old_backing) {
2946 error_reportf_err(local_err,
2947 "Could not open old backing file '%s': ",
2948 backing_name);
2949 goto out;
2950 }
2951
2952 if (out_baseimg[0]) {
2953 if (out_basefmt) {
2954 options = qdict_new();
2955 qdict_put(options, "driver", qstring_from_str(out_basefmt));
2956 } else {
2957 options = NULL;
2958 }
2959
2960 blk_new_backing = blk_new_open(out_baseimg, NULL,
2961 options, src_flags, &local_err);
2962 if (!blk_new_backing) {
2963 error_reportf_err(local_err,
2964 "Could not open new backing file '%s': ",
2965 out_baseimg);
2966 goto out;
2967 }
2968 }
2969 }
2970
2971 /*
2972 * Check each unallocated cluster in the COW file. If it is unallocated,
2973 * accesses go to the backing file. We must therefore compare this cluster
2974 * in the old and new backing file, and if they differ we need to copy it
2975 * from the old backing file into the COW file.
2976 *
2977 * If qemu-img crashes during this step, no harm is done. The content of
2978 * the image is the same as the original one at any time.
2979 */
2980 if (!unsafe) {
2981 int64_t num_sectors;
2982 int64_t old_backing_num_sectors;
2983 int64_t new_backing_num_sectors = 0;
2984 uint64_t sector;
2985 int n;
2986 float local_progress = 0;
2987
2988 buf_old = blk_blockalign(blk, IO_BUF_SIZE);
2989 buf_new = blk_blockalign(blk, IO_BUF_SIZE);
2990
2991 num_sectors = blk_nb_sectors(blk);
2992 if (num_sectors < 0) {
2993 error_report("Could not get size of '%s': %s",
2994 filename, strerror(-num_sectors));
2995 ret = -1;
2996 goto out;
2997 }
2998 old_backing_num_sectors = blk_nb_sectors(blk_old_backing);
2999 if (old_backing_num_sectors < 0) {
3000 char backing_name[PATH_MAX];
3001
3002 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
3003 error_report("Could not get size of '%s': %s",
3004 backing_name, strerror(-old_backing_num_sectors));
3005 ret = -1;
3006 goto out;
3007 }
3008 if (blk_new_backing) {
3009 new_backing_num_sectors = blk_nb_sectors(blk_new_backing);
3010 if (new_backing_num_sectors < 0) {
3011 error_report("Could not get size of '%s': %s",
3012 out_baseimg, strerror(-new_backing_num_sectors));
3013 ret = -1;
3014 goto out;
3015 }
3016 }
3017
3018 if (num_sectors != 0) {
3019 local_progress = (float)100 /
3020 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
3021 }
3022
3023 for (sector = 0; sector < num_sectors; sector += n) {
3024
3025 /* How many sectors can we handle with the next read? */
3026 if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
3027 n = (IO_BUF_SIZE / 512);
3028 } else {
3029 n = num_sectors - sector;
3030 }
3031
3032 /* If the cluster is allocated, we don't need to take action */
3033 ret = bdrv_is_allocated(bs, sector, n, &n);
3034 if (ret < 0) {
3035 error_report("error while reading image metadata: %s",
3036 strerror(-ret));
3037 goto out;
3038 }
3039 if (ret) {
3040 continue;
3041 }
3042
3043 /*
3044 * Read old and new backing file and take into consideration that
3045 * backing files may be smaller than the COW image.
3046 */
3047 if (sector >= old_backing_num_sectors) {
3048 memset(buf_old, 0, n * BDRV_SECTOR_SIZE);
3049 } else {
3050 if (sector + n > old_backing_num_sectors) {
3051 n = old_backing_num_sectors - sector;
3052 }
3053
3054 ret = blk_pread(blk_old_backing, sector << BDRV_SECTOR_BITS,
3055 buf_old, n << BDRV_SECTOR_BITS);
3056 if (ret < 0) {
3057 error_report("error while reading from old backing file");
3058 goto out;
3059 }
3060 }
3061
3062 if (sector >= new_backing_num_sectors || !blk_new_backing) {
3063 memset(buf_new, 0, n * BDRV_SECTOR_SIZE);
3064 } else {
3065 if (sector + n > new_backing_num_sectors) {
3066 n = new_backing_num_sectors - sector;
3067 }
3068
3069 ret = blk_pread(blk_new_backing, sector << BDRV_SECTOR_BITS,
3070 buf_new, n << BDRV_SECTOR_BITS);
3071 if (ret < 0) {
3072 error_report("error while reading from new backing file");
3073 goto out;
3074 }
3075 }
3076
3077 /* If they differ, we need to write to the COW file */
3078 uint64_t written = 0;
3079
3080 while (written < n) {
3081 int pnum;
3082
3083 if (compare_sectors(buf_old + written * 512,
3084 buf_new + written * 512, n - written, &pnum))
3085 {
3086 ret = blk_pwrite(blk,
3087 (sector + written) << BDRV_SECTOR_BITS,
3088 buf_old + written * 512,
3089 pnum << BDRV_SECTOR_BITS, 0);
3090 if (ret < 0) {
3091 error_report("Error while writing to COW image: %s",
3092 strerror(-ret));
3093 goto out;
3094 }
3095 }
3096
3097 written += pnum;
3098 }
3099 qemu_progress_print(local_progress, 100);
3100 }
3101 }
3102
3103 /*
3104 * Change the backing file. All clusters that are different from the old
3105 * backing file are overwritten in the COW file now, so the visible content
3106 * doesn't change when we switch the backing file.
3107 */
3108 if (out_baseimg && *out_baseimg) {
3109 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
3110 } else {
3111 ret = bdrv_change_backing_file(bs, NULL, NULL);
3112 }
3113
3114 if (ret == -ENOSPC) {
3115 error_report("Could not change the backing file to '%s': No "
3116 "space left in the file header", out_baseimg);
3117 } else if (ret < 0) {
3118 error_report("Could not change the backing file to '%s': %s",
3119 out_baseimg, strerror(-ret));
3120 }
3121
3122 qemu_progress_print(100, 0);
3123 /*
3124 * TODO At this point it is possible to check if any clusters that are
3125 * allocated in the COW file are the same in the backing file. If so, they
3126 * could be dropped from the COW file. Don't do this before switching the
3127 * backing file, in case of a crash this would lead to corruption.
3128 */
3129 out:
3130 qemu_progress_end();
3131 /* Cleanup */
3132 if (!unsafe) {
3133 blk_unref(blk_old_backing);
3134 blk_unref(blk_new_backing);
3135 }
3136 qemu_vfree(buf_old);
3137 qemu_vfree(buf_new);
3138
3139 blk_unref(blk);
3140 if (ret) {
3141 return 1;
3142 }
3143 return 0;
3144 }
3145
3146 static int img_resize(int argc, char **argv)
3147 {
3148 Error *err = NULL;
3149 int c, ret, relative;
3150 const char *filename, *fmt, *size;
3151 int64_t n, total_size;
3152 bool quiet = false;
3153 BlockBackend *blk = NULL;
3154 QemuOpts *param;
3155
3156 static QemuOptsList resize_options = {
3157 .name = "resize_options",
3158 .head = QTAILQ_HEAD_INITIALIZER(resize_options.head),
3159 .desc = {
3160 {
3161 .name = BLOCK_OPT_SIZE,
3162 .type = QEMU_OPT_SIZE,
3163 .help = "Virtual disk size"
3164 }, {
3165 /* end of list */
3166 }
3167 },
3168 };
3169 bool image_opts = false;
3170
3171 /* Remove size from argv manually so that negative numbers are not treated
3172 * as options by getopt. */
3173 if (argc < 3) {
3174 error_exit("Not enough arguments");
3175 return 1;
3176 }
3177
3178 size = argv[--argc];
3179
3180 /* Parse getopt arguments */
3181 fmt = NULL;
3182 for(;;) {
3183 static const struct option long_options[] = {
3184 {"help", no_argument, 0, 'h'},
3185 {"object", required_argument, 0, OPTION_OBJECT},
3186 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
3187 {0, 0, 0, 0}
3188 };
3189 c = getopt_long(argc, argv, "f:hq",
3190 long_options, NULL);
3191 if (c == -1) {
3192 break;
3193 }
3194 switch(c) {
3195 case '?':
3196 case 'h':
3197 help();
3198 break;
3199 case 'f':
3200 fmt = optarg;
3201 break;
3202 case 'q':
3203 quiet = true;
3204 break;
3205 case OPTION_OBJECT: {
3206 QemuOpts *opts;
3207 opts = qemu_opts_parse_noisily(&qemu_object_opts,
3208 optarg, true);
3209 if (!opts) {
3210 return 1;
3211 }
3212 } break;
3213 case OPTION_IMAGE_OPTS:
3214 image_opts = true;
3215 break;
3216 }
3217 }
3218 if (optind != argc - 1) {
3219 error_exit("Expecting one image file name");
3220 }
3221 filename = argv[optind++];
3222
3223 if (qemu_opts_foreach(&qemu_object_opts,
3224 user_creatable_add_opts_foreach,
3225 NULL, NULL)) {
3226 return 1;
3227 }
3228
3229 /* Choose grow, shrink, or absolute resize mode */
3230 switch (size[0]) {
3231 case '+':
3232 relative = 1;
3233 size++;
3234 break;
3235 case '-':
3236 relative = -1;
3237 size++;
3238 break;
3239 default:
3240 relative = 0;
3241 break;
3242 }
3243
3244 /* Parse size */
3245 param = qemu_opts_create(&resize_options, NULL, 0, &error_abort);
3246 qemu_opt_set(param, BLOCK_OPT_SIZE, size, &err);
3247 if (err) {
3248 error_report_err(err);
3249 ret = -1;
3250 qemu_opts_del(param);
3251 goto out;
3252 }
3253 n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
3254 qemu_opts_del(param);
3255
3256 blk = img_open(image_opts, filename, fmt,
3257 BDRV_O_RDWR, false, quiet);
3258 if (!blk) {
3259 ret = -1;
3260 goto out;
3261 }
3262
3263 if (relative) {
3264 total_size = blk_getlength(blk) + n * relative;
3265 } else {
3266 total_size = n;
3267 }
3268 if (total_size <= 0) {
3269 error_report("New image size must be positive");
3270 ret = -1;
3271 goto out;
3272 }
3273
3274 ret = blk_truncate(blk, total_size);
3275 switch (ret) {
3276 case 0:
3277 qprintf(quiet, "Image resized.\n");
3278 break;
3279 case -ENOTSUP:
3280 error_report("This image does not support resize");
3281 break;
3282 case -EACCES:
3283 error_report("Image is read-only");
3284 break;
3285 default:
3286 error_report("Error resizing image (%d)", -ret);
3287 break;
3288 }
3289 out:
3290 blk_unref(blk);
3291 if (ret) {
3292 return 1;
3293 }
3294 return 0;
3295 }
3296
3297 static void amend_status_cb(BlockDriverState *bs,
3298 int64_t offset, int64_t total_work_size,
3299 void *opaque)
3300 {
3301 qemu_progress_print(100.f * offset / total_work_size, 0);
3302 }
3303
3304 static int img_amend(int argc, char **argv)
3305 {
3306 Error *err = NULL;
3307 int c, ret = 0;
3308 char *options = NULL;
3309 QemuOptsList *create_opts = NULL;
3310 QemuOpts *opts = NULL;
3311 const char *fmt = NULL, *filename, *cache;
3312 int flags;
3313 bool writethrough;
3314 bool quiet = false, progress = false;
3315 BlockBackend *blk = NULL;
3316 BlockDriverState *bs = NULL;
3317 bool image_opts = false;
3318
3319 cache = BDRV_DEFAULT_CACHE;
3320 for (;;) {
3321 static const struct option long_options[] = {
3322 {"help", no_argument, 0, 'h'},
3323 {"object", required_argument, 0, OPTION_OBJECT},
3324 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
3325 {0, 0, 0, 0}
3326 };
3327 c = getopt_long(argc, argv, "ho:f:t:pq",
3328 long_options, NULL);
3329 if (c == -1) {
3330 break;
3331 }
3332
3333 switch (c) {
3334 case 'h':
3335 case '?':
3336 help();
3337 break;
3338 case 'o':
3339 if (!is_valid_option_list(optarg)) {
3340 error_report("Invalid option list: %s", optarg);
3341 ret = -1;
3342 goto out_no_progress;
3343 }
3344 if (!options) {
3345 options = g_strdup(optarg);
3346 } else {
3347 char *old_options = options;
3348 options = g_strdup_printf("%s,%s", options, optarg);
3349 g_free(old_options);
3350 }
3351 break;
3352 case 'f':
3353 fmt = optarg;
3354 break;
3355 case 't':
3356 cache = optarg;
3357 break;
3358 case 'p':
3359 progress = true;
3360 break;
3361 case 'q':
3362 quiet = true;
3363 break;
3364 case OPTION_OBJECT:
3365 opts = qemu_opts_parse_noisily(&qemu_object_opts,
3366 optarg, true);
3367 if (!opts) {
3368 ret = -1;
3369 goto out_no_progress;
3370 }
3371 break;
3372 case OPTION_IMAGE_OPTS:
3373 image_opts = true;
3374 break;
3375 }
3376 }
3377
3378 if (!options) {
3379 error_exit("Must specify options (-o)");
3380 }
3381
3382 if (qemu_opts_foreach(&qemu_object_opts,
3383 user_creatable_add_opts_foreach,
3384 NULL, NULL)) {
3385 ret = -1;
3386 goto out_no_progress;
3387 }
3388
3389 if (quiet) {
3390 progress = false;
3391 }
3392 qemu_progress_init(progress, 1.0);
3393
3394 filename = (optind == argc - 1) ? argv[argc - 1] : NULL;
3395 if (fmt && has_help_option(options)) {
3396 /* If a format is explicitly specified (and possibly no filename is
3397 * given), print option help here */
3398 ret = print_block_option_help(filename, fmt);
3399 goto out;
3400 }
3401
3402 if (optind != argc - 1) {
3403 error_report("Expecting one image file name");
3404 ret = -1;
3405 goto out;
3406 }
3407
3408 flags = BDRV_O_RDWR;
3409 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
3410 if (ret < 0) {
3411 error_report("Invalid cache option: %s", cache);
3412 goto out;
3413 }
3414
3415 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet);
3416 if (!blk) {
3417 ret = -1;
3418 goto out;
3419 }
3420 bs = blk_bs(blk);
3421
3422 fmt = bs->drv->format_name;
3423
3424 if (has_help_option(options)) {
3425 /* If the format was auto-detected, print option help here */
3426 ret = print_block_option_help(filename, fmt);
3427 goto out;
3428 }
3429
3430 if (!bs->drv->create_opts) {
3431 error_report("Format driver '%s' does not support any options to amend",
3432 fmt);
3433 ret = -1;
3434 goto out;
3435 }
3436
3437 create_opts = qemu_opts_append(create_opts, bs->drv->create_opts);
3438 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
3439 if (options) {
3440 qemu_opts_do_parse(opts, options, NULL, &err);
3441 if (err) {
3442 error_report_err(err);
3443 ret = -1;
3444 goto out;
3445 }
3446 }
3447
3448 /* In case the driver does not call amend_status_cb() */
3449 qemu_progress_print(0.f, 0);
3450 ret = bdrv_amend_options(bs, opts, &amend_status_cb, NULL);
3451 qemu_progress_print(100.f, 0);
3452 if (ret < 0) {
3453 error_report("Error while amending options: %s", strerror(-ret));
3454 goto out;
3455 }
3456
3457 out:
3458 qemu_progress_end();
3459
3460 out_no_progress:
3461 blk_unref(blk);
3462 qemu_opts_del(opts);
3463 qemu_opts_free(create_opts);
3464 g_free(options);
3465
3466 if (ret) {
3467 return 1;
3468 }
3469 return 0;
3470 }
3471
3472 typedef struct BenchData {
3473 BlockBackend *blk;
3474 uint64_t image_size;
3475 bool write;
3476 int bufsize;
3477 int step;
3478 int nrreq;
3479 int n;
3480 int flush_interval;
3481 bool drain_on_flush;
3482 uint8_t *buf;
3483 QEMUIOVector *qiov;
3484
3485 int in_flight;
3486 bool in_flush;
3487 uint64_t offset;
3488 } BenchData;
3489
3490 static void bench_undrained_flush_cb(void *opaque, int ret)
3491 {
3492 if (ret < 0) {
3493 error_report("Failed flush request: %s\n", strerror(-ret));
3494 exit(EXIT_FAILURE);
3495 }
3496 }
3497
3498 static void bench_cb(void *opaque, int ret)
3499 {
3500 BenchData *b = opaque;
3501 BlockAIOCB *acb;
3502
3503 if (ret < 0) {
3504 error_report("Failed request: %s\n", strerror(-ret));
3505 exit(EXIT_FAILURE);
3506 }
3507
3508 if (b->in_flush) {
3509 /* Just finished a flush with drained queue: Start next requests */
3510 assert(b->in_flight == 0);
3511 b->in_flush = false;
3512 } else if (b->in_flight > 0) {
3513 int remaining = b->n - b->in_flight;
3514
3515 b->n--;
3516 b->in_flight--;
3517
3518 /* Time for flush? Drain queue if requested, then flush */
3519 if (b->flush_interval && remaining % b->flush_interval == 0) {
3520 if (!b->in_flight || !b->drain_on_flush) {
3521 BlockCompletionFunc *cb;
3522
3523 if (b->drain_on_flush) {
3524 b->in_flush = true;
3525 cb = bench_cb;
3526 } else {
3527 cb = bench_undrained_flush_cb;
3528 }
3529
3530 acb = blk_aio_flush(b->blk, cb, b);
3531 if (!acb) {
3532 error_report("Failed to issue flush request");
3533 exit(EXIT_FAILURE);
3534 }
3535 }
3536 if (b->drain_on_flush) {
3537 return;
3538 }
3539 }
3540 }
3541
3542 while (b->n > b->in_flight && b->in_flight < b->nrreq) {
3543 if (b->write) {
3544 acb = blk_aio_pwritev(b->blk, b->offset, b->qiov, 0,
3545 bench_cb, b);
3546 } else {
3547 acb = blk_aio_preadv(b->blk, b->offset, b->qiov, 0,
3548 bench_cb, b);
3549 }
3550 if (!acb) {
3551 error_report("Failed to issue request");
3552 exit(EXIT_FAILURE);
3553 }
3554 b->in_flight++;
3555 b->offset += b->step;
3556 b->offset %= b->image_size;
3557 }
3558 }
3559
3560 static int img_bench(int argc, char **argv)
3561 {
3562 int c, ret = 0;
3563 const char *fmt = NULL, *filename;
3564 bool quiet = false;
3565 bool image_opts = false;
3566 bool is_write = false;
3567 int count = 75000;
3568 int depth = 64;
3569 int64_t offset = 0;
3570 size_t bufsize = 4096;
3571 int pattern = 0;
3572 size_t step = 0;
3573 int flush_interval = 0;
3574 bool drain_on_flush = true;
3575 int64_t image_size;
3576 BlockBackend *blk = NULL;
3577 BenchData data = {};
3578 int flags = 0;
3579 bool writethrough = false;
3580 struct timeval t1, t2;
3581 int i;
3582
3583 for (;;) {
3584 static const struct option long_options[] = {
3585 {"help", no_argument, 0, 'h'},
3586 {"flush-interval", required_argument, 0, OPTION_FLUSH_INTERVAL},
3587 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
3588 {"pattern", required_argument, 0, OPTION_PATTERN},
3589 {"no-drain", no_argument, 0, OPTION_NO_DRAIN},
3590 {0, 0, 0, 0}
3591 };
3592 c = getopt_long(argc, argv, "hc:d:f:no:qs:S:t:w", long_options, NULL);
3593 if (c == -1) {
3594 break;
3595 }
3596
3597 switch (c) {
3598 case 'h':
3599 case '?':
3600 help();
3601 break;
3602 case 'c':
3603 {
3604 char *end;
3605 errno = 0;
3606 count = strtoul(optarg, &end, 0);
3607 if (errno || *end || count > INT_MAX) {
3608 error_report("Invalid request count specified");
3609 return 1;
3610 }
3611 break;
3612 }
3613 case 'd':
3614 {
3615 char *end;
3616 errno = 0;
3617 depth = strtoul(optarg, &end, 0);
3618 if (errno || *end || depth > INT_MAX) {
3619 error_report("Invalid queue depth specified");
3620 return 1;
3621 }
3622 break;
3623 }
3624 case 'f':
3625 fmt = optarg;
3626 break;
3627 case 'n':
3628 flags |= BDRV_O_NATIVE_AIO;
3629 break;
3630 case 'o':
3631 {
3632 char *end;
3633 errno = 0;
3634 offset = qemu_strtosz_suffix(optarg, &end,
3635 QEMU_STRTOSZ_DEFSUFFIX_B);
3636 if (offset < 0|| *end) {
3637 error_report("Invalid offset specified");
3638 return 1;
3639 }
3640 break;
3641 }
3642 break;
3643 case 'q':
3644 quiet = true;
3645 break;
3646 case 's':
3647 {
3648 int64_t sval;
3649 char *end;
3650
3651 sval = qemu_strtosz_suffix(optarg, &end, QEMU_STRTOSZ_DEFSUFFIX_B);
3652 if (sval < 0 || sval > INT_MAX || *end) {
3653 error_report("Invalid buffer size specified");
3654 return 1;
3655 }
3656
3657 bufsize = sval;
3658 break;
3659 }
3660 case 'S':
3661 {
3662 int64_t sval;
3663 char *end;
3664
3665 sval = qemu_strtosz_suffix(optarg, &end, QEMU_STRTOSZ_DEFSUFFIX_B);
3666 if (sval < 0 || sval > INT_MAX || *end) {
3667 error_report("Invalid step size specified");
3668 return 1;
3669 }
3670
3671 step = sval;
3672 break;
3673 }
3674 case 't':
3675 ret = bdrv_parse_cache_mode(optarg, &flags, &writethrough);
3676 if (ret < 0) {
3677 error_report("Invalid cache mode");
3678 ret = -1;
3679 goto out;
3680 }
3681 break;
3682 case 'w':
3683 flags |= BDRV_O_RDWR;
3684 is_write = true;
3685 break;
3686 case OPTION_PATTERN:
3687 {
3688 char *end;
3689 errno = 0;
3690 pattern = strtoul(optarg, &end, 0);
3691 if (errno || *end || pattern > 0xff) {
3692 error_report("Invalid pattern byte specified");
3693 return 1;
3694 }
3695 break;
3696 }
3697 case OPTION_FLUSH_INTERVAL:
3698 {
3699 char *end;
3700 errno = 0;
3701 flush_interval = strtoul(optarg, &end, 0);
3702 if (errno || *end || flush_interval > INT_MAX) {
3703 error_report("Invalid flush interval specified");
3704 return 1;
3705 }
3706 break;
3707 }
3708 case OPTION_NO_DRAIN:
3709 drain_on_flush = false;
3710 break;
3711 case OPTION_IMAGE_OPTS:
3712 image_opts = true;
3713 break;
3714 }
3715 }
3716
3717 if (optind != argc - 1) {
3718 error_exit("Expecting one image file name");
3719 }
3720 filename = argv[argc - 1];
3721
3722 if (!is_write && flush_interval) {
3723 error_report("--flush-interval is only available in write tests");
3724 ret = -1;
3725 goto out;
3726 }
3727 if (flush_interval && flush_interval < depth) {
3728 error_report("Flush interval can't be smaller than depth");
3729 ret = -1;
3730 goto out;
3731 }
3732
3733 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet);
3734 if (!blk) {
3735 ret = -1;
3736 goto out;
3737 }
3738
3739 image_size = blk_getlength(blk);
3740 if (image_size < 0) {
3741 ret = image_size;
3742 goto out;
3743 }
3744
3745 data = (BenchData) {
3746 .blk = blk,
3747 .image_size = image_size,
3748 .bufsize = bufsize,
3749 .step = step ?: bufsize,
3750 .nrreq = depth,
3751 .n = count,
3752 .offset = offset,
3753 .write = is_write,
3754 .flush_interval = flush_interval,
3755 .drain_on_flush = drain_on_flush,
3756 };
3757 printf("Sending %d %s requests, %d bytes each, %d in parallel "
3758 "(starting at offset %" PRId64 ", step size %d)\n",
3759 data.n, data.write ? "write" : "read", data.bufsize, data.nrreq,
3760 data.offset, data.step);
3761 if (flush_interval) {
3762 printf("Sending flush every %d requests\n", flush_interval);
3763 }
3764
3765 data.buf = blk_blockalign(blk, data.nrreq * data.bufsize);
3766 memset(data.buf, pattern, data.nrreq * data.bufsize);
3767
3768 data.qiov = g_new(QEMUIOVector, data.nrreq);
3769 for (i = 0; i < data.nrreq; i++) {
3770 qemu_iovec_init(&data.qiov[i], 1);
3771 qemu_iovec_add(&data.qiov[i],
3772 data.buf + i * data.bufsize, data.bufsize);
3773 }
3774
3775 gettimeofday(&t1, NULL);
3776 bench_cb(&data, 0);
3777
3778 while (data.n > 0) {
3779 main_loop_wait(false);
3780 }
3781 gettimeofday(&t2, NULL);
3782
3783 printf("Run completed in %3.3f seconds.\n",
3784 (t2.tv_sec - t1.tv_sec)
3785 + ((double)(t2.tv_usec - t1.tv_usec) / 1000000));
3786
3787 out:
3788 qemu_vfree(data.buf);
3789 blk_unref(blk);
3790
3791 if (ret) {
3792 return 1;
3793 }
3794 return 0;
3795 }
3796
3797
3798 static const img_cmd_t img_cmds[] = {
3799 #define DEF(option, callback, arg_string) \
3800 { option, callback },
3801 #include "qemu-img-cmds.h"
3802 #undef DEF
3803 #undef GEN_DOCS
3804 { NULL, NULL, },
3805 };
3806
3807 int main(int argc, char **argv)
3808 {
3809 const img_cmd_t *cmd;
3810 const char *cmdname;
3811 Error *local_error = NULL;
3812 char *trace_file = NULL;
3813 int c;
3814 static const struct option long_options[] = {
3815 {"help", no_argument, 0, 'h'},
3816 {"version", no_argument, 0, 'V'},
3817 {"trace", required_argument, NULL, 'T'},
3818 {0, 0, 0, 0}
3819 };
3820
3821 #ifdef CONFIG_POSIX
3822 signal(SIGPIPE, SIG_IGN);
3823 #endif
3824
3825 error_set_progname(argv[0]);
3826 qemu_init_exec_dir(argv[0]);
3827
3828 if (qemu_init_main_loop(&local_error)) {
3829 error_report_err(local_error);
3830 exit(EXIT_FAILURE);
3831 }
3832
3833 qcrypto_init(&error_fatal);
3834
3835 module_call_init(MODULE_INIT_QOM);
3836 bdrv_init();
3837 if (argc < 2) {
3838 error_exit("Not enough arguments");
3839 }
3840
3841 qemu_add_opts(&qemu_object_opts);
3842 qemu_add_opts(&qemu_source_opts);
3843 qemu_add_opts(&qemu_trace_opts);
3844
3845 while ((c = getopt_long(argc, argv, "+hVT:", long_options, NULL)) != -1) {
3846 switch (c) {
3847 case 'h':
3848 help();
3849 return 0;
3850 case 'V':
3851 printf(QEMU_IMG_VERSION);
3852 return 0;
3853 case 'T':
3854 g_free(trace_file);
3855 trace_file = trace_opt_parse(optarg);
3856 break;
3857 }
3858 }
3859
3860 cmdname = argv[optind];
3861
3862 /* reset getopt_long scanning */
3863 argc -= optind;
3864 if (argc < 1) {
3865 return 0;
3866 }
3867 argv += optind;
3868 optind = 0;
3869
3870 if (!trace_init_backends()) {
3871 exit(1);
3872 }
3873 trace_init_file(trace_file);
3874 qemu_set_log(LOG_TRACE);
3875
3876 /* find the command */
3877 for (cmd = img_cmds; cmd->name != NULL; cmd++) {
3878 if (!strcmp(cmdname, cmd->name)) {
3879 return cmd->handler(argc, argv);
3880 }
3881 }
3882
3883 /* not found */
3884 error_exit("Command not found: %s", cmdname);
3885 }
Random patches