?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
qemu-img: Don't leak errors when outputting JSON
[qemu/kevin.git] / qemu-img.c
blobdebd7f13833d46fafa26016a52eb86740f98ffc7
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 QmpOutputVisitor *ov = qmp_output_visitor_new();
495 QObject *obj;
496 visit_type_ImageCheck(qmp_output_get_visitor(ov), NULL, &check,
497 &error_abort);
498 obj = qmp_output_get_qobject(ov);
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 qmp_output_visitor_cleanup(ov);
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 = bdrv_make_zero(blk_bs(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_length
2088 * or discard_alignment of the out_bs is greater. Limit to 32768 (16MB)
2089 * as maximum. */
2090 bufsectors = MIN(32768,
2091 MAX(bufsectors, MAX(out_bs->bl.opt_transfer_length,
2092 out_bs->bl.discard_alignment))
2093 );
2094
2095 if (skip_create) {
2096 int64_t output_sectors = blk_nb_sectors(out_blk);
2097 if (output_sectors < 0) {
2098 error_report("unable to get output image length: %s",
2099 strerror(-output_sectors));
2100 ret = -1;
2101 goto out;
2102 } else if (output_sectors < total_sectors) {
2103 error_report("output file is smaller than input file");
2104 ret = -1;
2105 goto out;
2106 }
2107 }
2108
2109 cluster_sectors = 0;
2110 ret = bdrv_get_info(out_bs, &bdi);
2111 if (ret < 0) {
2112 if (compress) {
2113 error_report("could not get block driver info");
2114 goto out;
2115 }
2116 } else {
2117 compress = compress || bdi.needs_compressed_writes;
2118 cluster_sectors = bdi.cluster_size / BDRV_SECTOR_SIZE;
2119 }
2120
2121 state = (ImgConvertState) {
2122 .src = blk,
2123 .src_sectors = bs_sectors,
2124 .src_num = bs_n,
2125 .total_sectors = total_sectors,
2126 .target = out_blk,
2127 .compressed = compress,
2128 .target_has_backing = (bool) out_baseimg,
2129 .min_sparse = min_sparse,
2130 .cluster_sectors = cluster_sectors,
2131 .buf_sectors = bufsectors,
2132 };
2133 ret = convert_do_copy(&state);
2134
2135 out:
2136 if (!ret) {
2137 qemu_progress_print(100, 0);
2138 }
2139 qemu_progress_end();
2140 qemu_opts_del(opts);
2141 qemu_opts_free(create_opts);
2142 qemu_opts_del(sn_opts);
2143 blk_unref(out_blk);
2144 g_free(bs);
2145 if (blk) {
2146 for (bs_i = 0; bs_i < bs_n; bs_i++) {
2147 blk_unref(blk[bs_i]);
2148 }
2149 g_free(blk);
2150 }
2151 g_free(bs_sectors);
2152 fail_getopt:
2153 g_free(options);
2154
2155 if (ret) {
2156 return 1;
2157 }
2158 return 0;
2159 }
2160
2161
2162 static void dump_snapshots(BlockDriverState *bs)
2163 {
2164 QEMUSnapshotInfo *sn_tab, *sn;
2165 int nb_sns, i;
2166
2167 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
2168 if (nb_sns <= 0)
2169 return;
2170 printf("Snapshot list:\n");
2171 bdrv_snapshot_dump(fprintf, stdout, NULL);
2172 printf("\n");
2173 for(i = 0; i < nb_sns; i++) {
2174 sn = &sn_tab[i];
2175 bdrv_snapshot_dump(fprintf, stdout, sn);
2176 printf("\n");
2177 }
2178 g_free(sn_tab);
2179 }
2180
2181 static void dump_json_image_info_list(ImageInfoList *list)
2182 {
2183 QString *str;
2184 QmpOutputVisitor *ov = qmp_output_visitor_new();
2185 QObject *obj;
2186 visit_type_ImageInfoList(qmp_output_get_visitor(ov), NULL, &list,
2187 &error_abort);
2188 obj = qmp_output_get_qobject(ov);
2189 str = qobject_to_json_pretty(obj);
2190 assert(str != NULL);
2191 printf("%s\n", qstring_get_str(str));
2192 qobject_decref(obj);
2193 qmp_output_visitor_cleanup(ov);
2194 QDECREF(str);
2195 }
2196
2197 static void dump_json_image_info(ImageInfo *info)
2198 {
2199 QString *str;
2200 QmpOutputVisitor *ov = qmp_output_visitor_new();
2201 QObject *obj;
2202 visit_type_ImageInfo(qmp_output_get_visitor(ov), NULL, &info,
2203 &error_abort);
2204 obj = qmp_output_get_qobject(ov);
2205 str = qobject_to_json_pretty(obj);
2206 assert(str != NULL);
2207 printf("%s\n", qstring_get_str(str));
2208 qobject_decref(obj);
2209 qmp_output_visitor_cleanup(ov);
2210 QDECREF(str);
2211 }
2212
2213 static void dump_human_image_info_list(ImageInfoList *list)
2214 {
2215 ImageInfoList *elem;
2216 bool delim = false;
2217
2218 for (elem = list; elem; elem = elem->next) {
2219 if (delim) {
2220 printf("\n");
2221 }
2222 delim = true;
2223
2224 bdrv_image_info_dump(fprintf, stdout, elem->value);
2225 }
2226 }
2227
2228 static gboolean str_equal_func(gconstpointer a, gconstpointer b)
2229 {
2230 return strcmp(a, b) == 0;
2231 }
2232
2233 /**
2234 * Open an image file chain and return an ImageInfoList
2235 *
2236 * @filename: topmost image filename
2237 * @fmt: topmost image format (may be NULL to autodetect)
2238 * @chain: true - enumerate entire backing file chain
2239 * false - only topmost image file
2240 *
2241 * Returns a list of ImageInfo objects or NULL if there was an error opening an
2242 * image file. If there was an error a message will have been printed to
2243 * stderr.
2244 */
2245 static ImageInfoList *collect_image_info_list(bool image_opts,
2246 const char *filename,
2247 const char *fmt,
2248 bool chain)
2249 {
2250 ImageInfoList *head = NULL;
2251 ImageInfoList **last = &head;
2252 GHashTable *filenames;
2253 Error *err = NULL;
2254
2255 filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL);
2256
2257 while (filename) {
2258 BlockBackend *blk;
2259 BlockDriverState *bs;
2260 ImageInfo *info;
2261 ImageInfoList *elem;
2262
2263 if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) {
2264 error_report("Backing file '%s' creates an infinite loop.",
2265 filename);
2266 goto err;
2267 }
2268 g_hash_table_insert(filenames, (gpointer)filename, NULL);
2269
2270 blk = img_open(image_opts, filename, fmt,
2271 BDRV_O_NO_BACKING | BDRV_O_NO_IO, false, false);
2272 if (!blk) {
2273 goto err;
2274 }
2275 bs = blk_bs(blk);
2276
2277 bdrv_query_image_info(bs, &info, &err);
2278 if (err) {
2279 error_report_err(err);
2280 blk_unref(blk);
2281 goto err;
2282 }
2283
2284 elem = g_new0(ImageInfoList, 1);
2285 elem->value = info;
2286 *last = elem;
2287 last = &elem->next;
2288
2289 blk_unref(blk);
2290
2291 filename = fmt = NULL;
2292 if (chain) {
2293 if (info->has_full_backing_filename) {
2294 filename = info->full_backing_filename;
2295 } else if (info->has_backing_filename) {
2296 error_report("Could not determine absolute backing filename,"
2297 " but backing filename '%s' present",
2298 info->backing_filename);
2299 goto err;
2300 }
2301 if (info->has_backing_filename_format) {
2302 fmt = info->backing_filename_format;
2303 }
2304 }
2305 }
2306 g_hash_table_destroy(filenames);
2307 return head;
2308
2309 err:
2310 qapi_free_ImageInfoList(head);
2311 g_hash_table_destroy(filenames);
2312 return NULL;
2313 }
2314
2315 static int img_info(int argc, char **argv)
2316 {
2317 int c;
2318 OutputFormat output_format = OFORMAT_HUMAN;
2319 bool chain = false;
2320 const char *filename, *fmt, *output;
2321 ImageInfoList *list;
2322 bool image_opts = false;
2323
2324 fmt = NULL;
2325 output = NULL;
2326 for(;;) {
2327 int option_index = 0;
2328 static const struct option long_options[] = {
2329 {"help", no_argument, 0, 'h'},
2330 {"format", required_argument, 0, 'f'},
2331 {"output", required_argument, 0, OPTION_OUTPUT},
2332 {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN},
2333 {"object", required_argument, 0, OPTION_OBJECT},
2334 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
2335 {0, 0, 0, 0}
2336 };
2337 c = getopt_long(argc, argv, "f:h",
2338 long_options, &option_index);
2339 if (c == -1) {
2340 break;
2341 }
2342 switch(c) {
2343 case '?':
2344 case 'h':
2345 help();
2346 break;
2347 case 'f':
2348 fmt = optarg;
2349 break;
2350 case OPTION_OUTPUT:
2351 output = optarg;
2352 break;
2353 case OPTION_BACKING_CHAIN:
2354 chain = true;
2355 break;
2356 case OPTION_OBJECT: {
2357 QemuOpts *opts;
2358 opts = qemu_opts_parse_noisily(&qemu_object_opts,
2359 optarg, true);
2360 if (!opts) {
2361 return 1;
2362 }
2363 } break;
2364 case OPTION_IMAGE_OPTS:
2365 image_opts = true;
2366 break;
2367 }
2368 }
2369 if (optind != argc - 1) {
2370 error_exit("Expecting one image file name");
2371 }
2372 filename = argv[optind++];
2373
2374 if (output && !strcmp(output, "json")) {
2375 output_format = OFORMAT_JSON;
2376 } else if (output && !strcmp(output, "human")) {
2377 output_format = OFORMAT_HUMAN;
2378 } else if (output) {
2379 error_report("--output must be used with human or json as argument.");
2380 return 1;
2381 }
2382
2383 if (qemu_opts_foreach(&qemu_object_opts,
2384 user_creatable_add_opts_foreach,
2385 NULL, NULL)) {
2386 return 1;
2387 }
2388
2389 list = collect_image_info_list(image_opts, filename, fmt, chain);
2390 if (!list) {
2391 return 1;
2392 }
2393
2394 switch (output_format) {
2395 case OFORMAT_HUMAN:
2396 dump_human_image_info_list(list);
2397 break;
2398 case OFORMAT_JSON:
2399 if (chain) {
2400 dump_json_image_info_list(list);
2401 } else {
2402 dump_json_image_info(list->value);
2403 }
2404 break;
2405 }
2406
2407 qapi_free_ImageInfoList(list);
2408 return 0;
2409 }
2410
2411 static void dump_map_entry(OutputFormat output_format, MapEntry *e,
2412 MapEntry *next)
2413 {
2414 switch (output_format) {
2415 case OFORMAT_HUMAN:
2416 if (e->data && !e->has_offset) {
2417 error_report("File contains external, encrypted or compressed clusters.");
2418 exit(1);
2419 }
2420 if (e->data && !e->zero) {
2421 printf("%#-16"PRIx64"%#-16"PRIx64"%#-16"PRIx64"%s\n",
2422 e->start, e->length,
2423 e->has_offset ? e->offset : 0,
2424 e->has_filename ? e->filename : "");
2425 }
2426 /* This format ignores the distinction between 0, ZERO and ZERO|DATA.
2427 * Modify the flags here to allow more coalescing.
2428 */
2429 if (next && (!next->data || next->zero)) {
2430 next->data = false;
2431 next->zero = true;
2432 }
2433 break;
2434 case OFORMAT_JSON:
2435 printf("%s{ \"start\": %"PRId64", \"length\": %"PRId64","
2436 " \"depth\": %"PRId64", \"zero\": %s, \"data\": %s",
2437 (e->start == 0 ? "[" : ",\n"),
2438 e->start, e->length, e->depth,
2439 e->zero ? "true" : "false",
2440 e->data ? "true" : "false");
2441 if (e->has_offset) {
2442 printf(", \"offset\": %"PRId64"", e->offset);
2443 }
2444 putchar('}');
2445
2446 if (!next) {
2447 printf("]\n");
2448 }
2449 break;
2450 }
2451 }
2452
2453 static int get_block_status(BlockDriverState *bs, int64_t sector_num,
2454 int nb_sectors, MapEntry *e)
2455 {
2456 int64_t ret;
2457 int depth;
2458 BlockDriverState *file;
2459 bool has_offset;
2460
2461 /* As an optimization, we could cache the current range of unallocated
2462 * clusters in each file of the chain, and avoid querying the same
2463 * range repeatedly.
2464 */
2465
2466 depth = 0;
2467 for (;;) {
2468 ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &nb_sectors,
2469 &file);
2470 if (ret < 0) {
2471 return ret;
2472 }
2473 assert(nb_sectors);
2474 if (ret & (BDRV_BLOCK_ZERO|BDRV_BLOCK_DATA)) {
2475 break;
2476 }
2477 bs = backing_bs(bs);
2478 if (bs == NULL) {
2479 ret = 0;
2480 break;
2481 }
2482
2483 depth++;
2484 }
2485
2486 has_offset = !!(ret & BDRV_BLOCK_OFFSET_VALID);
2487
2488 *e = (MapEntry) {
2489 .start = sector_num * BDRV_SECTOR_SIZE,
2490 .length = nb_sectors * BDRV_SECTOR_SIZE,
2491 .data = !!(ret & BDRV_BLOCK_DATA),
2492 .zero = !!(ret & BDRV_BLOCK_ZERO),
2493 .offset = ret & BDRV_BLOCK_OFFSET_MASK,
2494 .has_offset = has_offset,
2495 .depth = depth,
2496 .has_filename = file && has_offset,
2497 .filename = file && has_offset ? file->filename : NULL,
2498 };
2499
2500 return 0;
2501 }
2502
2503 static inline bool entry_mergeable(const MapEntry *curr, const MapEntry *next)
2504 {
2505 if (curr->length == 0) {
2506 return false;
2507 }
2508 if (curr->zero != next->zero ||
2509 curr->data != next->data ||
2510 curr->depth != next->depth ||
2511 curr->has_filename != next->has_filename ||
2512 curr->has_offset != next->has_offset) {
2513 return false;
2514 }
2515 if (curr->has_filename && strcmp(curr->filename, next->filename)) {
2516 return false;
2517 }
2518 if (curr->has_offset && curr->offset + curr->length != next->offset) {
2519 return false;
2520 }
2521 return true;
2522 }
2523
2524 static int img_map(int argc, char **argv)
2525 {
2526 int c;
2527 OutputFormat output_format = OFORMAT_HUMAN;
2528 BlockBackend *blk;
2529 BlockDriverState *bs;
2530 const char *filename, *fmt, *output;
2531 int64_t length;
2532 MapEntry curr = { .length = 0 }, next;
2533 int ret = 0;
2534 bool image_opts = false;
2535
2536 fmt = NULL;
2537 output = NULL;
2538 for (;;) {
2539 int option_index = 0;
2540 static const struct option long_options[] = {
2541 {"help", no_argument, 0, 'h'},
2542 {"format", required_argument, 0, 'f'},
2543 {"output", required_argument, 0, OPTION_OUTPUT},
2544 {"object", required_argument, 0, OPTION_OBJECT},
2545 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
2546 {0, 0, 0, 0}
2547 };
2548 c = getopt_long(argc, argv, "f:h",
2549 long_options, &option_index);
2550 if (c == -1) {
2551 break;
2552 }
2553 switch (c) {
2554 case '?':
2555 case 'h':
2556 help();
2557 break;
2558 case 'f':
2559 fmt = optarg;
2560 break;
2561 case OPTION_OUTPUT:
2562 output = optarg;
2563 break;
2564 case OPTION_OBJECT: {
2565 QemuOpts *opts;
2566 opts = qemu_opts_parse_noisily(&qemu_object_opts,
2567 optarg, true);
2568 if (!opts) {
2569 return 1;
2570 }
2571 } break;
2572 case OPTION_IMAGE_OPTS:
2573 image_opts = true;
2574 break;
2575 }
2576 }
2577 if (optind != argc - 1) {
2578 error_exit("Expecting one image file name");
2579 }
2580 filename = argv[optind];
2581
2582 if (output && !strcmp(output, "json")) {
2583 output_format = OFORMAT_JSON;
2584 } else if (output && !strcmp(output, "human")) {
2585 output_format = OFORMAT_HUMAN;
2586 } else if (output) {
2587 error_report("--output must be used with human or json as argument.");
2588 return 1;
2589 }
2590
2591 if (qemu_opts_foreach(&qemu_object_opts,
2592 user_creatable_add_opts_foreach,
2593 NULL, NULL)) {
2594 return 1;
2595 }
2596
2597 blk = img_open(image_opts, filename, fmt, 0, false, false);
2598 if (!blk) {
2599 return 1;
2600 }
2601 bs = blk_bs(blk);
2602
2603 if (output_format == OFORMAT_HUMAN) {
2604 printf("%-16s%-16s%-16s%s\n", "Offset", "Length", "Mapped to", "File");
2605 }
2606
2607 length = blk_getlength(blk);
2608 while (curr.start + curr.length < length) {
2609 int64_t nsectors_left;
2610 int64_t sector_num;
2611 int n;
2612
2613 sector_num = (curr.start + curr.length) >> BDRV_SECTOR_BITS;
2614
2615 /* Probe up to 1 GiB at a time. */
2616 nsectors_left = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE) - sector_num;
2617 n = MIN(1 << (30 - BDRV_SECTOR_BITS), nsectors_left);
2618 ret = get_block_status(bs, sector_num, n, &next);
2619
2620 if (ret < 0) {
2621 error_report("Could not read file metadata: %s", strerror(-ret));
2622 goto out;
2623 }
2624
2625 if (entry_mergeable(&curr, &next)) {
2626 curr.length += next.length;
2627 continue;
2628 }
2629
2630 if (curr.length > 0) {
2631 dump_map_entry(output_format, &curr, &next);
2632 }
2633 curr = next;
2634 }
2635
2636 dump_map_entry(output_format, &curr, NULL);
2637
2638 out:
2639 blk_unref(blk);
2640 return ret < 0;
2641 }
2642
2643 #define SNAPSHOT_LIST 1
2644 #define SNAPSHOT_CREATE 2
2645 #define SNAPSHOT_APPLY 3
2646 #define SNAPSHOT_DELETE 4
2647
2648 static int img_snapshot(int argc, char **argv)
2649 {
2650 BlockBackend *blk;
2651 BlockDriverState *bs;
2652 QEMUSnapshotInfo sn;
2653 char *filename, *snapshot_name = NULL;
2654 int c, ret = 0, bdrv_oflags;
2655 int action = 0;
2656 qemu_timeval tv;
2657 bool quiet = false;
2658 Error *err = NULL;
2659 bool image_opts = false;
2660
2661 bdrv_oflags = BDRV_O_RDWR;
2662 /* Parse commandline parameters */
2663 for(;;) {
2664 static const struct option long_options[] = {
2665 {"help", no_argument, 0, 'h'},
2666 {"object", required_argument, 0, OPTION_OBJECT},
2667 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
2668 {0, 0, 0, 0}
2669 };
2670 c = getopt_long(argc, argv, "la:c:d:hq",
2671 long_options, NULL);
2672 if (c == -1) {
2673 break;
2674 }
2675 switch(c) {
2676 case '?':
2677 case 'h':
2678 help();
2679 return 0;
2680 case 'l':
2681 if (action) {
2682 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2683 return 0;
2684 }
2685 action = SNAPSHOT_LIST;
2686 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
2687 break;
2688 case 'a':
2689 if (action) {
2690 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2691 return 0;
2692 }
2693 action = SNAPSHOT_APPLY;
2694 snapshot_name = optarg;
2695 break;
2696 case 'c':
2697 if (action) {
2698 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2699 return 0;
2700 }
2701 action = SNAPSHOT_CREATE;
2702 snapshot_name = optarg;
2703 break;
2704 case 'd':
2705 if (action) {
2706 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2707 return 0;
2708 }
2709 action = SNAPSHOT_DELETE;
2710 snapshot_name = optarg;
2711 break;
2712 case 'q':
2713 quiet = true;
2714 break;
2715 case OPTION_OBJECT: {
2716 QemuOpts *opts;
2717 opts = qemu_opts_parse_noisily(&qemu_object_opts,
2718 optarg, true);
2719 if (!opts) {
2720 return 1;
2721 }
2722 } break;
2723 case OPTION_IMAGE_OPTS:
2724 image_opts = true;
2725 break;
2726 }
2727 }
2728
2729 if (optind != argc - 1) {
2730 error_exit("Expecting one image file name");
2731 }
2732 filename = argv[optind++];
2733
2734 if (qemu_opts_foreach(&qemu_object_opts,
2735 user_creatable_add_opts_foreach,
2736 NULL, NULL)) {
2737 return 1;
2738 }
2739
2740 /* Open the image */
2741 blk = img_open(image_opts, filename, NULL, bdrv_oflags, false, quiet);
2742 if (!blk) {
2743 return 1;
2744 }
2745 bs = blk_bs(blk);
2746
2747 /* Perform the requested action */
2748 switch(action) {
2749 case SNAPSHOT_LIST:
2750 dump_snapshots(bs);
2751 break;
2752
2753 case SNAPSHOT_CREATE:
2754 memset(&sn, 0, sizeof(sn));
2755 pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
2756
2757 qemu_gettimeofday(&tv);
2758 sn.date_sec = tv.tv_sec;
2759 sn.date_nsec = tv.tv_usec * 1000;
2760
2761 ret = bdrv_snapshot_create(bs, &sn);
2762 if (ret) {
2763 error_report("Could not create snapshot '%s': %d (%s)",
2764 snapshot_name, ret, strerror(-ret));
2765 }
2766 break;
2767
2768 case SNAPSHOT_APPLY:
2769 ret = bdrv_snapshot_goto(bs, snapshot_name);
2770 if (ret) {
2771 error_report("Could not apply snapshot '%s': %d (%s)",
2772 snapshot_name, ret, strerror(-ret));
2773 }
2774 break;
2775
2776 case SNAPSHOT_DELETE:
2777 bdrv_snapshot_delete_by_id_or_name(bs, snapshot_name, &err);
2778 if (err) {
2779 error_reportf_err(err, "Could not delete snapshot '%s': ",
2780 snapshot_name);
2781 ret = 1;
2782 }
2783 break;
2784 }
2785
2786 /* Cleanup */
2787 blk_unref(blk);
2788 if (ret) {
2789 return 1;
2790 }
2791 return 0;
2792 }
2793
2794 static int img_rebase(int argc, char **argv)
2795 {
2796 BlockBackend *blk = NULL, *blk_old_backing = NULL, *blk_new_backing = NULL;
2797 uint8_t *buf_old = NULL;
2798 uint8_t *buf_new = NULL;
2799 BlockDriverState *bs = NULL;
2800 char *filename;
2801 const char *fmt, *cache, *src_cache, *out_basefmt, *out_baseimg;
2802 int c, flags, src_flags, ret;
2803 bool writethrough, src_writethrough;
2804 int unsafe = 0;
2805 int progress = 0;
2806 bool quiet = false;
2807 Error *local_err = NULL;
2808 bool image_opts = false;
2809
2810 /* Parse commandline parameters */
2811 fmt = NULL;
2812 cache = BDRV_DEFAULT_CACHE;
2813 src_cache = BDRV_DEFAULT_CACHE;
2814 out_baseimg = NULL;
2815 out_basefmt = NULL;
2816 for(;;) {
2817 static const struct option long_options[] = {
2818 {"help", no_argument, 0, 'h'},
2819 {"object", required_argument, 0, OPTION_OBJECT},
2820 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
2821 {0, 0, 0, 0}
2822 };
2823 c = getopt_long(argc, argv, "hf:F:b:upt:T:q",
2824 long_options, NULL);
2825 if (c == -1) {
2826 break;
2827 }
2828 switch(c) {
2829 case '?':
2830 case 'h':
2831 help();
2832 return 0;
2833 case 'f':
2834 fmt = optarg;
2835 break;
2836 case 'F':
2837 out_basefmt = optarg;
2838 break;
2839 case 'b':
2840 out_baseimg = optarg;
2841 break;
2842 case 'u':
2843 unsafe = 1;
2844 break;
2845 case 'p':
2846 progress = 1;
2847 break;
2848 case 't':
2849 cache = optarg;
2850 break;
2851 case 'T':
2852 src_cache = optarg;
2853 break;
2854 case 'q':
2855 quiet = true;
2856 break;
2857 case OPTION_OBJECT: {
2858 QemuOpts *opts;
2859 opts = qemu_opts_parse_noisily(&qemu_object_opts,
2860 optarg, true);
2861 if (!opts) {
2862 return 1;
2863 }
2864 } break;
2865 case OPTION_IMAGE_OPTS:
2866 image_opts = true;
2867 break;
2868 }
2869 }
2870
2871 if (quiet) {
2872 progress = 0;
2873 }
2874
2875 if (optind != argc - 1) {
2876 error_exit("Expecting one image file name");
2877 }
2878 if (!unsafe && !out_baseimg) {
2879 error_exit("Must specify backing file (-b) or use unsafe mode (-u)");
2880 }
2881 filename = argv[optind++];
2882
2883 if (qemu_opts_foreach(&qemu_object_opts,
2884 user_creatable_add_opts_foreach,
2885 NULL, NULL)) {
2886 return 1;
2887 }
2888
2889 qemu_progress_init(progress, 2.0);
2890 qemu_progress_print(0, 100);
2891
2892 flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
2893 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
2894 if (ret < 0) {
2895 error_report("Invalid cache option: %s", cache);
2896 goto out;
2897 }
2898
2899 src_flags = 0;
2900 ret = bdrv_parse_cache_mode(src_cache, &src_flags, &src_writethrough);
2901 if (ret < 0) {
2902 error_report("Invalid source cache option: %s", src_cache);
2903 goto out;
2904 }
2905
2906 /* The source files are opened read-only, don't care about WCE */
2907 assert((src_flags & BDRV_O_RDWR) == 0);
2908 (void) src_writethrough;
2909
2910 /*
2911 * Open the images.
2912 *
2913 * Ignore the old backing file for unsafe rebase in case we want to correct
2914 * the reference to a renamed or moved backing file.
2915 */
2916 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet);
2917 if (!blk) {
2918 ret = -1;
2919 goto out;
2920 }
2921 bs = blk_bs(blk);
2922
2923 if (out_basefmt != NULL) {
2924 if (bdrv_find_format(out_basefmt) == NULL) {
2925 error_report("Invalid format name: '%s'", out_basefmt);
2926 ret = -1;
2927 goto out;
2928 }
2929 }
2930
2931 /* For safe rebasing we need to compare old and new backing file */
2932 if (!unsafe) {
2933 char backing_name[PATH_MAX];
2934 QDict *options = NULL;
2935
2936 if (bs->backing_format[0] != '\0') {
2937 options = qdict_new();
2938 qdict_put(options, "driver", qstring_from_str(bs->backing_format));
2939 }
2940
2941 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
2942 blk_old_backing = blk_new_open(backing_name, NULL,
2943 options, src_flags, &local_err);
2944 if (!blk_old_backing) {
2945 error_reportf_err(local_err,
2946 "Could not open old backing file '%s': ",
2947 backing_name);
2948 goto out;
2949 }
2950
2951 if (out_baseimg[0]) {
2952 if (out_basefmt) {
2953 options = qdict_new();
2954 qdict_put(options, "driver", qstring_from_str(out_basefmt));
2955 } else {
2956 options = NULL;
2957 }
2958
2959 blk_new_backing = blk_new_open(out_baseimg, NULL,
2960 options, src_flags, &local_err);
2961 if (!blk_new_backing) {
2962 error_reportf_err(local_err,
2963 "Could not open new backing file '%s': ",
2964 out_baseimg);
2965 goto out;
2966 }
2967 }
2968 }
2969
2970 /*
2971 * Check each unallocated cluster in the COW file. If it is unallocated,
2972 * accesses go to the backing file. We must therefore compare this cluster
2973 * in the old and new backing file, and if they differ we need to copy it
2974 * from the old backing file into the COW file.
2975 *
2976 * If qemu-img crashes during this step, no harm is done. The content of
2977 * the image is the same as the original one at any time.
2978 */
2979 if (!unsafe) {
2980 int64_t num_sectors;
2981 int64_t old_backing_num_sectors;
2982 int64_t new_backing_num_sectors = 0;
2983 uint64_t sector;
2984 int n;
2985 float local_progress = 0;
2986
2987 buf_old = blk_blockalign(blk, IO_BUF_SIZE);
2988 buf_new = blk_blockalign(blk, IO_BUF_SIZE);
2989
2990 num_sectors = blk_nb_sectors(blk);
2991 if (num_sectors < 0) {
2992 error_report("Could not get size of '%s': %s",
2993 filename, strerror(-num_sectors));
2994 ret = -1;
2995 goto out;
2996 }
2997 old_backing_num_sectors = blk_nb_sectors(blk_old_backing);
2998 if (old_backing_num_sectors < 0) {
2999 char backing_name[PATH_MAX];
3000
3001 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
3002 error_report("Could not get size of '%s': %s",
3003 backing_name, strerror(-old_backing_num_sectors));
3004 ret = -1;
3005 goto out;
3006 }
3007 if (blk_new_backing) {
3008 new_backing_num_sectors = blk_nb_sectors(blk_new_backing);
3009 if (new_backing_num_sectors < 0) {
3010 error_report("Could not get size of '%s': %s",
3011 out_baseimg, strerror(-new_backing_num_sectors));
3012 ret = -1;
3013 goto out;
3014 }
3015 }
3016
3017 if (num_sectors != 0) {
3018 local_progress = (float)100 /
3019 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
3020 }
3021
3022 for (sector = 0; sector < num_sectors; sector += n) {
3023
3024 /* How many sectors can we handle with the next read? */
3025 if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
3026 n = (IO_BUF_SIZE / 512);
3027 } else {
3028 n = num_sectors - sector;
3029 }
3030
3031 /* If the cluster is allocated, we don't need to take action */
3032 ret = bdrv_is_allocated(bs, sector, n, &n);
3033 if (ret < 0) {
3034 error_report("error while reading image metadata: %s",
3035 strerror(-ret));
3036 goto out;
3037 }
3038 if (ret) {
3039 continue;
3040 }
3041
3042 /*
3043 * Read old and new backing file and take into consideration that
3044 * backing files may be smaller than the COW image.
3045 */
3046 if (sector >= old_backing_num_sectors) {
3047 memset(buf_old, 0, n * BDRV_SECTOR_SIZE);
3048 } else {
3049 if (sector + n > old_backing_num_sectors) {
3050 n = old_backing_num_sectors - sector;
3051 }
3052
3053 ret = blk_pread(blk_old_backing, sector << BDRV_SECTOR_BITS,
3054 buf_old, n << BDRV_SECTOR_BITS);
3055 if (ret < 0) {
3056 error_report("error while reading from old backing file");
3057 goto out;
3058 }
3059 }
3060
3061 if (sector >= new_backing_num_sectors || !blk_new_backing) {
3062 memset(buf_new, 0, n * BDRV_SECTOR_SIZE);
3063 } else {
3064 if (sector + n > new_backing_num_sectors) {
3065 n = new_backing_num_sectors - sector;
3066 }
3067
3068 ret = blk_pread(blk_new_backing, sector << BDRV_SECTOR_BITS,
3069 buf_new, n << BDRV_SECTOR_BITS);
3070 if (ret < 0) {
3071 error_report("error while reading from new backing file");
3072 goto out;
3073 }
3074 }
3075
3076 /* If they differ, we need to write to the COW file */
3077 uint64_t written = 0;
3078
3079 while (written < n) {
3080 int pnum;
3081
3082 if (compare_sectors(buf_old + written * 512,
3083 buf_new + written * 512, n - written, &pnum))
3084 {
3085 ret = blk_pwrite(blk,
3086 (sector + written) << BDRV_SECTOR_BITS,
3087 buf_old + written * 512,
3088 pnum << BDRV_SECTOR_BITS, 0);
3089 if (ret < 0) {
3090 error_report("Error while writing to COW image: %s",
3091 strerror(-ret));
3092 goto out;
3093 }
3094 }
3095
3096 written += pnum;
3097 }
3098 qemu_progress_print(local_progress, 100);
3099 }
3100 }
3101
3102 /*
3103 * Change the backing file. All clusters that are different from the old
3104 * backing file are overwritten in the COW file now, so the visible content
3105 * doesn't change when we switch the backing file.
3106 */
3107 if (out_baseimg && *out_baseimg) {
3108 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
3109 } else {
3110 ret = bdrv_change_backing_file(bs, NULL, NULL);
3111 }
3112
3113 if (ret == -ENOSPC) {
3114 error_report("Could not change the backing file to '%s': No "
3115 "space left in the file header", out_baseimg);
3116 } else if (ret < 0) {
3117 error_report("Could not change the backing file to '%s': %s",
3118 out_baseimg, strerror(-ret));
3119 }
3120
3121 qemu_progress_print(100, 0);
3122 /*
3123 * TODO At this point it is possible to check if any clusters that are
3124 * allocated in the COW file are the same in the backing file. If so, they
3125 * could be dropped from the COW file. Don't do this before switching the
3126 * backing file, in case of a crash this would lead to corruption.
3127 */
3128 out:
3129 qemu_progress_end();
3130 /* Cleanup */
3131 if (!unsafe) {
3132 blk_unref(blk_old_backing);
3133 blk_unref(blk_new_backing);
3134 }
3135 qemu_vfree(buf_old);
3136 qemu_vfree(buf_new);
3137
3138 blk_unref(blk);
3139 if (ret) {
3140 return 1;
3141 }
3142 return 0;
3143 }
3144
3145 static int img_resize(int argc, char **argv)
3146 {
3147 Error *err = NULL;
3148 int c, ret, relative;
3149 const char *filename, *fmt, *size;
3150 int64_t n, total_size;
3151 bool quiet = false;
3152 BlockBackend *blk = NULL;
3153 QemuOpts *param;
3154
3155 static QemuOptsList resize_options = {
3156 .name = "resize_options",
3157 .head = QTAILQ_HEAD_INITIALIZER(resize_options.head),
3158 .desc = {
3159 {
3160 .name = BLOCK_OPT_SIZE,
3161 .type = QEMU_OPT_SIZE,
3162 .help = "Virtual disk size"
3163 }, {
3164 /* end of list */
3165 }
3166 },
3167 };
3168 bool image_opts = false;
3169
3170 /* Remove size from argv manually so that negative numbers are not treated
3171 * as options by getopt. */
3172 if (argc < 3) {
3173 error_exit("Not enough arguments");
3174 return 1;
3175 }
3176
3177 size = argv[--argc];
3178
3179 /* Parse getopt arguments */
3180 fmt = NULL;
3181 for(;;) {
3182 static const struct option long_options[] = {
3183 {"help", no_argument, 0, 'h'},
3184 {"object", required_argument, 0, OPTION_OBJECT},
3185 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
3186 {0, 0, 0, 0}
3187 };
3188 c = getopt_long(argc, argv, "f:hq",
3189 long_options, NULL);
3190 if (c == -1) {
3191 break;
3192 }
3193 switch(c) {
3194 case '?':
3195 case 'h':
3196 help();
3197 break;
3198 case 'f':
3199 fmt = optarg;
3200 break;
3201 case 'q':
3202 quiet = true;
3203 break;
3204 case OPTION_OBJECT: {
3205 QemuOpts *opts;
3206 opts = qemu_opts_parse_noisily(&qemu_object_opts,
3207 optarg, true);
3208 if (!opts) {
3209 return 1;
3210 }
3211 } break;
3212 case OPTION_IMAGE_OPTS:
3213 image_opts = true;
3214 break;
3215 }
3216 }
3217 if (optind != argc - 1) {
3218 error_exit("Expecting one image file name");
3219 }
3220 filename = argv[optind++];
3221
3222 if (qemu_opts_foreach(&qemu_object_opts,
3223 user_creatable_add_opts_foreach,
3224 NULL, NULL)) {
3225 return 1;
3226 }
3227
3228 /* Choose grow, shrink, or absolute resize mode */
3229 switch (size[0]) {
3230 case '+':
3231 relative = 1;
3232 size++;
3233 break;
3234 case '-':
3235 relative = -1;
3236 size++;
3237 break;
3238 default:
3239 relative = 0;
3240 break;
3241 }
3242
3243 /* Parse size */
3244 param = qemu_opts_create(&resize_options, NULL, 0, &error_abort);
3245 qemu_opt_set(param, BLOCK_OPT_SIZE, size, &err);
3246 if (err) {
3247 error_report_err(err);
3248 ret = -1;
3249 qemu_opts_del(param);
3250 goto out;
3251 }
3252 n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
3253 qemu_opts_del(param);
3254
3255 blk = img_open(image_opts, filename, fmt,
3256 BDRV_O_RDWR, false, quiet);
3257 if (!blk) {
3258 ret = -1;
3259 goto out;
3260 }
3261
3262 if (relative) {
3263 total_size = blk_getlength(blk) + n * relative;
3264 } else {
3265 total_size = n;
3266 }
3267 if (total_size <= 0) {
3268 error_report("New image size must be positive");
3269 ret = -1;
3270 goto out;
3271 }
3272
3273 ret = blk_truncate(blk, total_size);
3274 switch (ret) {
3275 case 0:
3276 qprintf(quiet, "Image resized.\n");
3277 break;
3278 case -ENOTSUP:
3279 error_report("This image does not support resize");
3280 break;
3281 case -EACCES:
3282 error_report("Image is read-only");
3283 break;
3284 default:
3285 error_report("Error resizing image (%d)", -ret);
3286 break;
3287 }
3288 out:
3289 blk_unref(blk);
3290 if (ret) {
3291 return 1;
3292 }
3293 return 0;
3294 }
3295
3296 static void amend_status_cb(BlockDriverState *bs,
3297 int64_t offset, int64_t total_work_size,
3298 void *opaque)
3299 {
3300 qemu_progress_print(100.f * offset / total_work_size, 0);
3301 }
3302
3303 static int img_amend(int argc, char **argv)
3304 {
3305 Error *err = NULL;
3306 int c, ret = 0;
3307 char *options = NULL;
3308 QemuOptsList *create_opts = NULL;
3309 QemuOpts *opts = NULL;
3310 const char *fmt = NULL, *filename, *cache;
3311 int flags;
3312 bool writethrough;
3313 bool quiet = false, progress = false;
3314 BlockBackend *blk = NULL;
3315 BlockDriverState *bs = NULL;
3316 bool image_opts = false;
3317
3318 cache = BDRV_DEFAULT_CACHE;
3319 for (;;) {
3320 static const struct option long_options[] = {
3321 {"help", no_argument, 0, 'h'},
3322 {"object", required_argument, 0, OPTION_OBJECT},
3323 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
3324 {0, 0, 0, 0}
3325 };
3326 c = getopt_long(argc, argv, "ho:f:t:pq",
3327 long_options, NULL);
3328 if (c == -1) {
3329 break;
3330 }
3331
3332 switch (c) {
3333 case 'h':
3334 case '?':
3335 help();
3336 break;
3337 case 'o':
3338 if (!is_valid_option_list(optarg)) {
3339 error_report("Invalid option list: %s", optarg);
3340 ret = -1;
3341 goto out_no_progress;
3342 }
3343 if (!options) {
3344 options = g_strdup(optarg);
3345 } else {
3346 char *old_options = options;
3347 options = g_strdup_printf("%s,%s", options, optarg);
3348 g_free(old_options);
3349 }
3350 break;
3351 case 'f':
3352 fmt = optarg;
3353 break;
3354 case 't':
3355 cache = optarg;
3356 break;
3357 case 'p':
3358 progress = true;
3359 break;
3360 case 'q':
3361 quiet = true;
3362 break;
3363 case OPTION_OBJECT:
3364 opts = qemu_opts_parse_noisily(&qemu_object_opts,
3365 optarg, true);
3366 if (!opts) {
3367 ret = -1;
3368 goto out_no_progress;
3369 }
3370 break;
3371 case OPTION_IMAGE_OPTS:
3372 image_opts = true;
3373 break;
3374 }
3375 }
3376
3377 if (!options) {
3378 error_exit("Must specify options (-o)");
3379 }
3380
3381 if (qemu_opts_foreach(&qemu_object_opts,
3382 user_creatable_add_opts_foreach,
3383 NULL, NULL)) {
3384 ret = -1;
3385 goto out_no_progress;
3386 }
3387
3388 if (quiet) {
3389 progress = false;
3390 }
3391 qemu_progress_init(progress, 1.0);
3392
3393 filename = (optind == argc - 1) ? argv[argc - 1] : NULL;
3394 if (fmt && has_help_option(options)) {
3395 /* If a format is explicitly specified (and possibly no filename is
3396 * given), print option help here */
3397 ret = print_block_option_help(filename, fmt);
3398 goto out;
3399 }
3400
3401 if (optind != argc - 1) {
3402 error_report("Expecting one image file name");
3403 ret = -1;
3404 goto out;
3405 }
3406
3407 flags = BDRV_O_RDWR;
3408 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
3409 if (ret < 0) {
3410 error_report("Invalid cache option: %s", cache);
3411 goto out;
3412 }
3413
3414 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet);
3415 if (!blk) {
3416 ret = -1;
3417 goto out;
3418 }
3419 bs = blk_bs(blk);
3420
3421 fmt = bs->drv->format_name;
3422
3423 if (has_help_option(options)) {
3424 /* If the format was auto-detected, print option help here */
3425 ret = print_block_option_help(filename, fmt);
3426 goto out;
3427 }
3428
3429 if (!bs->drv->create_opts) {
3430 error_report("Format driver '%s' does not support any options to amend",
3431 fmt);
3432 ret = -1;
3433 goto out;
3434 }
3435
3436 create_opts = qemu_opts_append(create_opts, bs->drv->create_opts);
3437 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
3438 if (options) {
3439 qemu_opts_do_parse(opts, options, NULL, &err);
3440 if (err) {
3441 error_report_err(err);
3442 ret = -1;
3443 goto out;
3444 }
3445 }
3446
3447 /* In case the driver does not call amend_status_cb() */
3448 qemu_progress_print(0.f, 0);
3449 ret = bdrv_amend_options(bs, opts, &amend_status_cb, NULL);
3450 qemu_progress_print(100.f, 0);
3451 if (ret < 0) {
3452 error_report("Error while amending options: %s", strerror(-ret));
3453 goto out;
3454 }
3455
3456 out:
3457 qemu_progress_end();
3458
3459 out_no_progress:
3460 blk_unref(blk);
3461 qemu_opts_del(opts);
3462 qemu_opts_free(create_opts);
3463 g_free(options);
3464
3465 if (ret) {
3466 return 1;
3467 }
3468 return 0;
3469 }
3470
3471 typedef struct BenchData {
3472 BlockBackend *blk;
3473 uint64_t image_size;
3474 bool write;
3475 int bufsize;
3476 int step;
3477 int nrreq;
3478 int n;
3479 int flush_interval;
3480 bool drain_on_flush;
3481 uint8_t *buf;
3482 QEMUIOVector *qiov;
3483
3484 int in_flight;
3485 bool in_flush;
3486 uint64_t offset;
3487 } BenchData;
3488
3489 static void bench_undrained_flush_cb(void *opaque, int ret)
3490 {
3491 if (ret < 0) {
3492 error_report("Failed flush request: %s\n", strerror(-ret));
3493 exit(EXIT_FAILURE);
3494 }
3495 }
3496
3497 static void bench_cb(void *opaque, int ret)
3498 {
3499 BenchData *b = opaque;
3500 BlockAIOCB *acb;
3501
3502 if (ret < 0) {
3503 error_report("Failed request: %s\n", strerror(-ret));
3504 exit(EXIT_FAILURE);
3505 }
3506
3507 if (b->in_flush) {
3508 /* Just finished a flush with drained queue: Start next requests */
3509 assert(b->in_flight == 0);
3510 b->in_flush = false;
3511 } else if (b->in_flight > 0) {
3512 int remaining = b->n - b->in_flight;
3513
3514 b->n--;
3515 b->in_flight--;
3516
3517 /* Time for flush? Drain queue if requested, then flush */
3518 if (b->flush_interval && remaining % b->flush_interval == 0) {
3519 if (!b->in_flight || !b->drain_on_flush) {
3520 BlockCompletionFunc *cb;
3521
3522 if (b->drain_on_flush) {
3523 b->in_flush = true;
3524 cb = bench_cb;
3525 } else {
3526 cb = bench_undrained_flush_cb;
3527 }
3528
3529 acb = blk_aio_flush(b->blk, cb, b);
3530 if (!acb) {
3531 error_report("Failed to issue flush request");
3532 exit(EXIT_FAILURE);
3533 }
3534 }
3535 if (b->drain_on_flush) {
3536 return;
3537 }
3538 }
3539 }
3540
3541 while (b->n > b->in_flight && b->in_flight < b->nrreq) {
3542 if (b->write) {
3543 acb = blk_aio_pwritev(b->blk, b->offset, b->qiov, 0,
3544 bench_cb, b);
3545 } else {
3546 acb = blk_aio_preadv(b->blk, b->offset, b->qiov, 0,
3547 bench_cb, b);
3548 }
3549 if (!acb) {
3550 error_report("Failed to issue request");
3551 exit(EXIT_FAILURE);
3552 }
3553 b->in_flight++;
3554 b->offset += b->step;
3555 b->offset %= b->image_size;
3556 }
3557 }
3558
3559 static int img_bench(int argc, char **argv)
3560 {
3561 int c, ret = 0;
3562 const char *fmt = NULL, *filename;
3563 bool quiet = false;
3564 bool image_opts = false;
3565 bool is_write = false;
3566 int count = 75000;
3567 int depth = 64;
3568 int64_t offset = 0;
3569 size_t bufsize = 4096;
3570 int pattern = 0;
3571 size_t step = 0;
3572 int flush_interval = 0;
3573 bool drain_on_flush = true;
3574 int64_t image_size;
3575 BlockBackend *blk = NULL;
3576 BenchData data = {};
3577 int flags = 0;
3578 bool writethrough = false;
3579 struct timeval t1, t2;
3580 int i;
3581
3582 for (;;) {
3583 static const struct option long_options[] = {
3584 {"help", no_argument, 0, 'h'},
3585 {"flush-interval", required_argument, 0, OPTION_FLUSH_INTERVAL},
3586 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
3587 {"pattern", required_argument, 0, OPTION_PATTERN},
3588 {"no-drain", no_argument, 0, OPTION_NO_DRAIN},
3589 {0, 0, 0, 0}
3590 };
3591 c = getopt_long(argc, argv, "hc:d:f:no:qs:S:t:w", long_options, NULL);
3592 if (c == -1) {
3593 break;
3594 }
3595
3596 switch (c) {
3597 case 'h':
3598 case '?':
3599 help();
3600 break;
3601 case 'c':
3602 {
3603 char *end;
3604 errno = 0;
3605 count = strtoul(optarg, &end, 0);
3606 if (errno || *end || count > INT_MAX) {
3607 error_report("Invalid request count specified");
3608 return 1;
3609 }
3610 break;
3611 }
3612 case 'd':
3613 {
3614 char *end;
3615 errno = 0;
3616 depth = strtoul(optarg, &end, 0);
3617 if (errno || *end || depth > INT_MAX) {
3618 error_report("Invalid queue depth specified");
3619 return 1;
3620 }
3621 break;
3622 }
3623 case 'f':
3624 fmt = optarg;
3625 break;
3626 case 'n':
3627 flags |= BDRV_O_NATIVE_AIO;
3628 break;
3629 case 'o':
3630 {
3631 char *end;
3632 errno = 0;
3633 offset = qemu_strtosz_suffix(optarg, &end,
3634 QEMU_STRTOSZ_DEFSUFFIX_B);
3635 if (offset < 0|| *end) {
3636 error_report("Invalid offset specified");
3637 return 1;
3638 }
3639 break;
3640 }
3641 break;
3642 case 'q':
3643 quiet = true;
3644 break;
3645 case 's':
3646 {
3647 int64_t sval;
3648 char *end;
3649
3650 sval = qemu_strtosz_suffix(optarg, &end, QEMU_STRTOSZ_DEFSUFFIX_B);
3651 if (sval < 0 || sval > INT_MAX || *end) {
3652 error_report("Invalid buffer size specified");
3653 return 1;
3654 }
3655
3656 bufsize = sval;
3657 break;
3658 }
3659 case 'S':
3660 {
3661 int64_t sval;
3662 char *end;
3663
3664 sval = qemu_strtosz_suffix(optarg, &end, QEMU_STRTOSZ_DEFSUFFIX_B);
3665 if (sval < 0 || sval > INT_MAX || *end) {
3666 error_report("Invalid step size specified");
3667 return 1;
3668 }
3669
3670 step = sval;
3671 break;
3672 }
3673 case 't':
3674 ret = bdrv_parse_cache_mode(optarg, &flags, &writethrough);
3675 if (ret < 0) {
3676 error_report("Invalid cache mode");
3677 ret = -1;
3678 goto out;
3679 }
3680 break;
3681 case 'w':
3682 flags |= BDRV_O_RDWR;
3683 is_write = true;
3684 break;
3685 case OPTION_PATTERN:
3686 {
3687 char *end;
3688 errno = 0;
3689 pattern = strtoul(optarg, &end, 0);
3690 if (errno || *end || pattern > 0xff) {
3691 error_report("Invalid pattern byte specified");
3692 return 1;
3693 }
3694 break;
3695 }
3696 case OPTION_FLUSH_INTERVAL:
3697 {
3698 char *end;
3699 errno = 0;
3700 flush_interval = strtoul(optarg, &end, 0);
3701 if (errno || *end || flush_interval > INT_MAX) {
3702 error_report("Invalid flush interval specified");
3703 return 1;
3704 }
3705 break;
3706 }
3707 case OPTION_NO_DRAIN:
3708 drain_on_flush = false;
3709 break;
3710 case OPTION_IMAGE_OPTS:
3711 image_opts = true;
3712 break;
3713 }
3714 }
3715
3716 if (optind != argc - 1) {
3717 error_exit("Expecting one image file name");
3718 }
3719 filename = argv[argc - 1];
3720
3721 if (!is_write && flush_interval) {
3722 error_report("--flush-interval is only available in write tests");
3723 ret = -1;
3724 goto out;
3725 }
3726 if (flush_interval && flush_interval < depth) {
3727 error_report("Flush interval can't be smaller than depth");
3728 ret = -1;
3729 goto out;
3730 }
3731
3732 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet);
3733 if (!blk) {
3734 ret = -1;
3735 goto out;
3736 }
3737
3738 image_size = blk_getlength(blk);
3739 if (image_size < 0) {
3740 ret = image_size;
3741 goto out;
3742 }
3743
3744 data = (BenchData) {
3745 .blk = blk,
3746 .image_size = image_size,
3747 .bufsize = bufsize,
3748 .step = step ?: bufsize,
3749 .nrreq = depth,
3750 .n = count,
3751 .offset = offset,
3752 .write = is_write,
3753 .flush_interval = flush_interval,
3754 .drain_on_flush = drain_on_flush,
3755 };
3756 printf("Sending %d %s requests, %d bytes each, %d in parallel "
3757 "(starting at offset %" PRId64 ", step size %d)\n",
3758 data.n, data.write ? "write" : "read", data.bufsize, data.nrreq,
3759 data.offset, data.step);
3760 if (flush_interval) {
3761 printf("Sending flush every %d requests\n", flush_interval);
3762 }
3763
3764 data.buf = blk_blockalign(blk, data.nrreq * data.bufsize);
3765 memset(data.buf, pattern, data.nrreq * data.bufsize);
3766
3767 data.qiov = g_new(QEMUIOVector, data.nrreq);
3768 for (i = 0; i < data.nrreq; i++) {
3769 qemu_iovec_init(&data.qiov[i], 1);
3770 qemu_iovec_add(&data.qiov[i],
3771 data.buf + i * data.bufsize, data.bufsize);
3772 }
3773
3774 gettimeofday(&t1, NULL);
3775 bench_cb(&data, 0);
3776
3777 while (data.n > 0) {
3778 main_loop_wait(false);
3779 }
3780 gettimeofday(&t2, NULL);
3781
3782 printf("Run completed in %3.3f seconds.\n",
3783 (t2.tv_sec - t1.tv_sec)
3784 + ((double)(t2.tv_usec - t1.tv_usec) / 1000000));
3785
3786 out:
3787 qemu_vfree(data.buf);
3788 blk_unref(blk);
3789
3790 if (ret) {
3791 return 1;
3792 }
3793 return 0;
3794 }
3795
3796
3797 static const img_cmd_t img_cmds[] = {
3798 #define DEF(option, callback, arg_string) \
3799 { option, callback },
3800 #include "qemu-img-cmds.h"
3801 #undef DEF
3802 #undef GEN_DOCS
3803 { NULL, NULL, },
3804 };
3805
3806 int main(int argc, char **argv)
3807 {
3808 const img_cmd_t *cmd;
3809 const char *cmdname;
3810 Error *local_error = NULL;
3811 char *trace_file = NULL;
3812 int c;
3813 static const struct option long_options[] = {
3814 {"help", no_argument, 0, 'h'},
3815 {"version", no_argument, 0, 'V'},
3816 {"trace", required_argument, NULL, 'T'},
3817 {0, 0, 0, 0}
3818 };
3819
3820 #ifdef CONFIG_POSIX
3821 signal(SIGPIPE, SIG_IGN);
3822 #endif
3823
3824 error_set_progname(argv[0]);
3825 qemu_init_exec_dir(argv[0]);
3826
3827 if (qemu_init_main_loop(&local_error)) {
3828 error_report_err(local_error);
3829 exit(EXIT_FAILURE);
3830 }
3831
3832 qcrypto_init(&error_fatal);
3833
3834 module_call_init(MODULE_INIT_QOM);
3835 bdrv_init();
3836 if (argc < 2) {
3837 error_exit("Not enough arguments");
3838 }
3839
3840 qemu_add_opts(&qemu_object_opts);
3841 qemu_add_opts(&qemu_source_opts);
3842 qemu_add_opts(&qemu_trace_opts);
3843
3844 while ((c = getopt_long(argc, argv, "+hVT:", long_options, NULL)) != -1) {
3845 switch (c) {
3846 case 'h':
3847 help();
3848 return 0;
3849 case 'V':
3850 printf(QEMU_IMG_VERSION);
3851 return 0;
3852 case 'T':
3853 g_free(trace_file);
3854 trace_file = trace_opt_parse(optarg);
3855 break;
3856 }
3857 }
3858
3859 cmdname = argv[optind];
3860
3861 /* reset getopt_long scanning */
3862 argc -= optind;
3863 if (argc < 1) {
3864 return 0;
3865 }
3866 argv += optind;
3867 optind = 1;
3868
3869 if (!trace_init_backends()) {
3870 exit(1);
3871 }
3872 trace_init_file(trace_file);
3873 qemu_set_log(LOG_TRACE);
3874
3875 /* find the command */
3876 for (cmd = img_cmds; cmd->name != NULL; cmd++) {
3877 if (!strcmp(cmdname, cmd->name)) {
3878 return cmd->handler(argc, argv);
3879 }
3880 }
3881
3882 /* not found */
3883 error_exit("Command not found: %s", cmdname);
3884 }
Random patches