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