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