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