hw/net: fix mcf_fec driver receiver
[qemu.git] / qemu-img.c
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 "qapi-visit.h"
25 #include "qapi/qmp-output-visitor.h"
26 #include "qapi/qmp/qerror.h"
27 #include "qapi/qmp/qjson.h"
28 #include "qemu-common.h"
29 #include "qemu/option.h"
30 #include "qemu/error-report.h"
31 #include "qemu/osdep.h"
32 #include "sysemu/sysemu.h"
33 #include "sysemu/block-backend.h"
34 #include "block/block_int.h"
35 #include "block/blockjob.h"
36 #include "block/qapi.h"
37 #include <getopt.h>
38
39 #define QEMU_IMG_VERSION "qemu-img version " QEMU_VERSION QEMU_PKGVERSION \
40 ", Copyright (c) 2004-2008 Fabrice Bellard\n"
41
42 typedef struct img_cmd_t {
43 const char *name;
44 int (*handler)(int argc, char **argv);
45 } img_cmd_t;
46
47 enum {
48 OPTION_OUTPUT = 256,
49 OPTION_BACKING_CHAIN = 257,
50 };
51
52 typedef enum OutputFormat {
53 OFORMAT_JSON,
54 OFORMAT_HUMAN,
55 } OutputFormat;
56
57 /* Default to cache=writeback as data integrity is not important for qemu-tcg. */
58 #define BDRV_O_FLAGS BDRV_O_CACHE_WB
59 #define BDRV_DEFAULT_CACHE "writeback"
60
61 static void format_print(void *opaque, const char *name)
62 {
63 printf(" %s", name);
64 }
65
66 static void QEMU_NORETURN GCC_FMT_ATTR(1, 2) error_exit(const char *fmt, ...)
67 {
68 va_list ap;
69
70 error_printf("qemu-img: ");
71
72 va_start(ap, fmt);
73 error_vprintf(fmt, ap);
74 va_end(ap);
75
76 error_printf("\nTry 'qemu-img --help' for more information\n");
77 exit(EXIT_FAILURE);
78 }
79
80 /* Please keep in synch with qemu-img.texi */
81 static void QEMU_NORETURN help(void)
82 {
83 const char *help_msg =
84 QEMU_IMG_VERSION
85 "usage: qemu-img command [command options]\n"
86 "QEMU disk image utility\n"
87 "\n"
88 "Command syntax:\n"
89 #define DEF(option, callback, arg_string) \
90 " " arg_string "\n"
91 #include "qemu-img-cmds.h"
92 #undef DEF
93 #undef GEN_DOCS
94 "\n"
95 "Command parameters:\n"
96 " 'filename' is a disk image filename\n"
97 " 'fmt' is the disk image format. It is guessed automatically in most cases\n"
98 " 'cache' is the cache mode used to write the output disk image, the valid\n"
99 " options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n"
100 " 'directsync' and 'unsafe' (default for convert)\n"
101 " 'src_cache' is the cache mode used to read input disk images, the valid\n"
102 " options are the same as for the 'cache' option\n"
103 " 'size' is the disk image size in bytes. Optional suffixes\n"
104 " 'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M),\n"
105 " 'T' (terabyte, 1024G), 'P' (petabyte, 1024T) and 'E' (exabyte, 1024P) are\n"
106 " supported. 'b' is ignored.\n"
107 " 'output_filename' is the destination disk image filename\n"
108 " 'output_fmt' is the destination format\n"
109 " 'options' is a comma separated list of format specific options in a\n"
110 " name=value format. Use -o ? for an overview of the options supported by the\n"
111 " used format\n"
112 " 'snapshot_param' is param used for internal snapshot, format\n"
113 " is 'snapshot.id=[ID],snapshot.name=[NAME]', or\n"
114 " '[ID_OR_NAME]'\n"
115 " 'snapshot_id_or_name' is deprecated, use 'snapshot_param'\n"
116 " instead\n"
117 " '-c' indicates that target image must be compressed (qcow format only)\n"
118 " '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
119 " match exactly. The image doesn't need a working backing file before\n"
120 " rebasing in this case (useful for renaming the backing file)\n"
121 " '-h' with or without a command shows this help and lists the supported formats\n"
122 " '-p' show progress of command (only certain commands)\n"
123 " '-q' use Quiet mode - do not print any output (except errors)\n"
124 " '-S' indicates the consecutive number of bytes (defaults to 4k) that must\n"
125 " contain only zeros for qemu-img to create a sparse image during\n"
126 " conversion. If the number of bytes is 0, the source will not be scanned for\n"
127 " unallocated or zero sectors, and the destination image will always be\n"
128 " fully allocated\n"
129 " '--output' takes the format in which the output must be done (human or json)\n"
130 " '-n' skips the target volume creation (useful if the volume is created\n"
131 " prior to running qemu-img)\n"
132 "\n"
133 "Parameters to check subcommand:\n"
134 " '-r' tries to repair any inconsistencies that are found during the check.\n"
135 " '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n"
136 " kinds of errors, with a higher risk of choosing the wrong fix or\n"
137 " hiding corruption that has already occurred.\n"
138 "\n"
139 "Parameters to snapshot subcommand:\n"
140 " 'snapshot' is the name of the snapshot to create, apply or delete\n"
141 " '-a' applies a snapshot (revert disk to saved state)\n"
142 " '-c' creates a snapshot\n"
143 " '-d' deletes a snapshot\n"
144 " '-l' lists all snapshots in the given image\n"
145 "\n"
146 "Parameters to compare subcommand:\n"
147 " '-f' first image format\n"
148 " '-F' second image format\n"
149 " '-s' run in Strict mode - fail on different image size or sector allocation\n";
150
151 printf("%s\nSupported formats:", help_msg);
152 bdrv_iterate_format(format_print, NULL);
153 printf("\n");
154 exit(EXIT_SUCCESS);
155 }
156
157 static int GCC_FMT_ATTR(2, 3) qprintf(bool quiet, const char *fmt, ...)
158 {
159 int ret = 0;
160 if (!quiet) {
161 va_list args;
162 va_start(args, fmt);
163 ret = vprintf(fmt, args);
164 va_end(args);
165 }
166 return ret;
167 }
168
169
170 static int print_block_option_help(const char *filename, const char *fmt)
171 {
172 BlockDriver *drv, *proto_drv;
173 QemuOptsList *create_opts = NULL;
174 Error *local_err = NULL;
175
176 /* Find driver and parse its options */
177 drv = bdrv_find_format(fmt);
178 if (!drv) {
179 error_report("Unknown file format '%s'", fmt);
180 return 1;
181 }
182
183 create_opts = qemu_opts_append(create_opts, drv->create_opts);
184 if (filename) {
185 proto_drv = bdrv_find_protocol(filename, true, &local_err);
186 if (!proto_drv) {
187 error_report_err(local_err);
188 qemu_opts_free(create_opts);
189 return 1;
190 }
191 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
192 }
193
194 qemu_opts_print_help(create_opts);
195 qemu_opts_free(create_opts);
196 return 0;
197 }
198
199 static BlockBackend *img_open(const char *id, const char *filename,
200 const char *fmt, int flags,
201 bool require_io, bool quiet)
202 {
203 BlockBackend *blk;
204 BlockDriverState *bs;
205 char password[256];
206 Error *local_err = NULL;
207 QDict *options = NULL;
208
209 if (fmt) {
210 options = qdict_new();
211 qdict_put(options, "driver", qstring_from_str(fmt));
212 }
213
214 blk = blk_new_open(id, filename, NULL, options, flags, &local_err);
215 if (!blk) {
216 error_report("Could not open '%s': %s", filename,
217 error_get_pretty(local_err));
218 error_free(local_err);
219 goto fail;
220 }
221
222 bs = blk_bs(blk);
223 if (bdrv_is_encrypted(bs) && require_io) {
224 qprintf(quiet, "Disk image '%s' is encrypted.\n", filename);
225 if (qemu_read_password(password, sizeof(password)) < 0) {
226 error_report("No password given");
227 goto fail;
228 }
229 if (bdrv_set_key(bs, password) < 0) {
230 error_report("invalid password");
231 goto fail;
232 }
233 }
234 return blk;
235 fail:
236 blk_unref(blk);
237 return NULL;
238 }
239
240 static int add_old_style_options(const char *fmt, QemuOpts *opts,
241 const char *base_filename,
242 const char *base_fmt)
243 {
244 Error *err = NULL;
245
246 if (base_filename) {
247 qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &err);
248 if (err) {
249 error_report("Backing file not supported for file format '%s'",
250 fmt);
251 error_free(err);
252 return -1;
253 }
254 }
255 if (base_fmt) {
256 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &err);
257 if (err) {
258 error_report("Backing file format not supported for file "
259 "format '%s'", fmt);
260 error_free(err);
261 return -1;
262 }
263 }
264 return 0;
265 }
266
267 static int img_create(int argc, char **argv)
268 {
269 int c;
270 uint64_t img_size = -1;
271 const char *fmt = "raw";
272 const char *base_fmt = NULL;
273 const char *filename;
274 const char *base_filename = NULL;
275 char *options = NULL;
276 Error *local_err = NULL;
277 bool quiet = false;
278
279 for(;;) {
280 c = getopt(argc, argv, "F:b:f:he6o:q");
281 if (c == -1) {
282 break;
283 }
284 switch(c) {
285 case '?':
286 case 'h':
287 help();
288 break;
289 case 'F':
290 base_fmt = optarg;
291 break;
292 case 'b':
293 base_filename = optarg;
294 break;
295 case 'f':
296 fmt = optarg;
297 break;
298 case 'e':
299 error_report("option -e is deprecated, please use \'-o "
300 "encryption\' instead!");
301 goto fail;
302 case '6':
303 error_report("option -6 is deprecated, please use \'-o "
304 "compat6\' instead!");
305 goto fail;
306 case 'o':
307 if (!is_valid_option_list(optarg)) {
308 error_report("Invalid option list: %s", optarg);
309 goto fail;
310 }
311 if (!options) {
312 options = g_strdup(optarg);
313 } else {
314 char *old_options = options;
315 options = g_strdup_printf("%s,%s", options, optarg);
316 g_free(old_options);
317 }
318 break;
319 case 'q':
320 quiet = true;
321 break;
322 }
323 }
324
325 /* Get the filename */
326 filename = (optind < argc) ? argv[optind] : NULL;
327 if (options && has_help_option(options)) {
328 g_free(options);
329 return print_block_option_help(filename, fmt);
330 }
331
332 if (optind >= argc) {
333 error_exit("Expecting image file name");
334 }
335 optind++;
336
337 /* Get image size, if specified */
338 if (optind < argc) {
339 int64_t sval;
340 char *end;
341 sval = strtosz_suffix(argv[optind++], &end, STRTOSZ_DEFSUFFIX_B);
342 if (sval < 0 || *end) {
343 if (sval == -ERANGE) {
344 error_report("Image size must be less than 8 EiB!");
345 } else {
346 error_report("Invalid image size specified! You may use k, M, "
347 "G, T, P or E suffixes for ");
348 error_report("kilobytes, megabytes, gigabytes, terabytes, "
349 "petabytes and exabytes.");
350 }
351 goto fail;
352 }
353 img_size = (uint64_t)sval;
354 }
355 if (optind != argc) {
356 error_exit("Unexpected argument: %s", argv[optind]);
357 }
358
359 bdrv_img_create(filename, fmt, base_filename, base_fmt,
360 options, img_size, BDRV_O_FLAGS, &local_err, quiet);
361 if (local_err) {
362 error_report("%s: %s", filename, error_get_pretty(local_err));
363 error_free(local_err);
364 goto fail;
365 }
366
367 g_free(options);
368 return 0;
369
370 fail:
371 g_free(options);
372 return 1;
373 }
374
375 static void dump_json_image_check(ImageCheck *check, bool quiet)
376 {
377 Error *local_err = NULL;
378 QString *str;
379 QmpOutputVisitor *ov = qmp_output_visitor_new();
380 QObject *obj;
381 visit_type_ImageCheck(qmp_output_get_visitor(ov),
382 &check, NULL, &local_err);
383 obj = qmp_output_get_qobject(ov);
384 str = qobject_to_json_pretty(obj);
385 assert(str != NULL);
386 qprintf(quiet, "%s\n", qstring_get_str(str));
387 qobject_decref(obj);
388 qmp_output_visitor_cleanup(ov);
389 QDECREF(str);
390 }
391
392 static void dump_human_image_check(ImageCheck *check, bool quiet)
393 {
394 if (!(check->corruptions || check->leaks || check->check_errors)) {
395 qprintf(quiet, "No errors were found on the image.\n");
396 } else {
397 if (check->corruptions) {
398 qprintf(quiet, "\n%" PRId64 " errors were found on the image.\n"
399 "Data may be corrupted, or further writes to the image "
400 "may corrupt it.\n",
401 check->corruptions);
402 }
403
404 if (check->leaks) {
405 qprintf(quiet,
406 "\n%" PRId64 " leaked clusters were found on the image.\n"
407 "This means waste of disk space, but no harm to data.\n",
408 check->leaks);
409 }
410
411 if (check->check_errors) {
412 qprintf(quiet,
413 "\n%" PRId64
414 " internal errors have occurred during the check.\n",
415 check->check_errors);
416 }
417 }
418
419 if (check->total_clusters != 0 && check->allocated_clusters != 0) {
420 qprintf(quiet, "%" PRId64 "/%" PRId64 " = %0.2f%% allocated, "
421 "%0.2f%% fragmented, %0.2f%% compressed clusters\n",
422 check->allocated_clusters, check->total_clusters,
423 check->allocated_clusters * 100.0 / check->total_clusters,
424 check->fragmented_clusters * 100.0 / check->allocated_clusters,
425 check->compressed_clusters * 100.0 /
426 check->allocated_clusters);
427 }
428
429 if (check->image_end_offset) {
430 qprintf(quiet,
431 "Image end offset: %" PRId64 "\n", check->image_end_offset);
432 }
433 }
434
435 static int collect_image_check(BlockDriverState *bs,
436 ImageCheck *check,
437 const char *filename,
438 const char *fmt,
439 int fix)
440 {
441 int ret;
442 BdrvCheckResult result;
443
444 ret = bdrv_check(bs, &result, fix);
445 if (ret < 0) {
446 return ret;
447 }
448
449 check->filename = g_strdup(filename);
450 check->format = g_strdup(bdrv_get_format_name(bs));
451 check->check_errors = result.check_errors;
452 check->corruptions = result.corruptions;
453 check->has_corruptions = result.corruptions != 0;
454 check->leaks = result.leaks;
455 check->has_leaks = result.leaks != 0;
456 check->corruptions_fixed = result.corruptions_fixed;
457 check->has_corruptions_fixed = result.corruptions != 0;
458 check->leaks_fixed = result.leaks_fixed;
459 check->has_leaks_fixed = result.leaks != 0;
460 check->image_end_offset = result.image_end_offset;
461 check->has_image_end_offset = result.image_end_offset != 0;
462 check->total_clusters = result.bfi.total_clusters;
463 check->has_total_clusters = result.bfi.total_clusters != 0;
464 check->allocated_clusters = result.bfi.allocated_clusters;
465 check->has_allocated_clusters = result.bfi.allocated_clusters != 0;
466 check->fragmented_clusters = result.bfi.fragmented_clusters;
467 check->has_fragmented_clusters = result.bfi.fragmented_clusters != 0;
468 check->compressed_clusters = result.bfi.compressed_clusters;
469 check->has_compressed_clusters = result.bfi.compressed_clusters != 0;
470
471 return 0;
472 }
473
474 /*
475 * Checks an image for consistency. Exit codes:
476 *
477 * 0 - Check completed, image is good
478 * 1 - Check not completed because of internal errors
479 * 2 - Check completed, image is corrupted
480 * 3 - Check completed, image has leaked clusters, but is good otherwise
481 * 63 - Checks are not supported by the image format
482 */
483 static int img_check(int argc, char **argv)
484 {
485 int c, ret;
486 OutputFormat output_format = OFORMAT_HUMAN;
487 const char *filename, *fmt, *output, *cache;
488 BlockBackend *blk;
489 BlockDriverState *bs;
490 int fix = 0;
491 int flags = BDRV_O_FLAGS | BDRV_O_CHECK;
492 ImageCheck *check;
493 bool quiet = false;
494
495 fmt = NULL;
496 output = NULL;
497 cache = BDRV_DEFAULT_CACHE;
498 for(;;) {
499 int option_index = 0;
500 static const struct option long_options[] = {
501 {"help", no_argument, 0, 'h'},
502 {"format", required_argument, 0, 'f'},
503 {"repair", required_argument, 0, 'r'},
504 {"output", required_argument, 0, OPTION_OUTPUT},
505 {0, 0, 0, 0}
506 };
507 c = getopt_long(argc, argv, "hf:r:T:q",
508 long_options, &option_index);
509 if (c == -1) {
510 break;
511 }
512 switch(c) {
513 case '?':
514 case 'h':
515 help();
516 break;
517 case 'f':
518 fmt = optarg;
519 break;
520 case 'r':
521 flags |= BDRV_O_RDWR;
522
523 if (!strcmp(optarg, "leaks")) {
524 fix = BDRV_FIX_LEAKS;
525 } else if (!strcmp(optarg, "all")) {
526 fix = BDRV_FIX_LEAKS | BDRV_FIX_ERRORS;
527 } else {
528 error_exit("Unknown option value for -r "
529 "(expecting 'leaks' or 'all'): %s", optarg);
530 }
531 break;
532 case OPTION_OUTPUT:
533 output = optarg;
534 break;
535 case 'T':
536 cache = optarg;
537 break;
538 case 'q':
539 quiet = true;
540 break;
541 }
542 }
543 if (optind != argc - 1) {
544 error_exit("Expecting one image file name");
545 }
546 filename = argv[optind++];
547
548 if (output && !strcmp(output, "json")) {
549 output_format = OFORMAT_JSON;
550 } else if (output && !strcmp(output, "human")) {
551 output_format = OFORMAT_HUMAN;
552 } else if (output) {
553 error_report("--output must be used with human or json as argument.");
554 return 1;
555 }
556
557 ret = bdrv_parse_cache_flags(cache, &flags);
558 if (ret < 0) {
559 error_report("Invalid source cache option: %s", cache);
560 return 1;
561 }
562
563 blk = img_open("image", filename, fmt, flags, true, quiet);
564 if (!blk) {
565 return 1;
566 }
567 bs = blk_bs(blk);
568
569 check = g_new0(ImageCheck, 1);
570 ret = collect_image_check(bs, check, filename, fmt, fix);
571
572 if (ret == -ENOTSUP) {
573 error_report("This image format does not support checks");
574 ret = 63;
575 goto fail;
576 }
577
578 if (check->corruptions_fixed || check->leaks_fixed) {
579 int corruptions_fixed, leaks_fixed;
580
581 leaks_fixed = check->leaks_fixed;
582 corruptions_fixed = check->corruptions_fixed;
583
584 if (output_format == OFORMAT_HUMAN) {
585 qprintf(quiet,
586 "The following inconsistencies were found and repaired:\n\n"
587 " %" PRId64 " leaked clusters\n"
588 " %" PRId64 " corruptions\n\n"
589 "Double checking the fixed image now...\n",
590 check->leaks_fixed,
591 check->corruptions_fixed);
592 }
593
594 ret = collect_image_check(bs, check, filename, fmt, 0);
595
596 check->leaks_fixed = leaks_fixed;
597 check->corruptions_fixed = corruptions_fixed;
598 }
599
600 if (!ret) {
601 switch (output_format) {
602 case OFORMAT_HUMAN:
603 dump_human_image_check(check, quiet);
604 break;
605 case OFORMAT_JSON:
606 dump_json_image_check(check, quiet);
607 break;
608 }
609 }
610
611 if (ret || check->check_errors) {
612 if (ret) {
613 error_report("Check failed: %s", strerror(-ret));
614 } else {
615 error_report("Check failed");
616 }
617 ret = 1;
618 goto fail;
619 }
620
621 if (check->corruptions) {
622 ret = 2;
623 } else if (check->leaks) {
624 ret = 3;
625 } else {
626 ret = 0;
627 }
628
629 fail:
630 qapi_free_ImageCheck(check);
631 blk_unref(blk);
632 return ret;
633 }
634
635 typedef struct CommonBlockJobCBInfo {
636 BlockDriverState *bs;
637 Error **errp;
638 } CommonBlockJobCBInfo;
639
640 static void common_block_job_cb(void *opaque, int ret)
641 {
642 CommonBlockJobCBInfo *cbi = opaque;
643
644 if (ret < 0) {
645 error_setg_errno(cbi->errp, -ret, "Block job failed");
646 }
647
648 /* Drop this block job's reference */
649 bdrv_unref(cbi->bs);
650 }
651
652 static void run_block_job(BlockJob *job, Error **errp)
653 {
654 AioContext *aio_context = bdrv_get_aio_context(job->bs);
655
656 do {
657 aio_poll(aio_context, true);
658 qemu_progress_print((float)job->offset / job->len * 100.f, 0);
659 } while (!job->ready);
660
661 block_job_complete_sync(job, errp);
662
663 /* A block job may finish instantaneously without publishing any progress,
664 * so just signal completion here */
665 qemu_progress_print(100.f, 0);
666 }
667
668 static int img_commit(int argc, char **argv)
669 {
670 int c, ret, flags;
671 const char *filename, *fmt, *cache, *base;
672 BlockBackend *blk;
673 BlockDriverState *bs, *base_bs;
674 bool progress = false, quiet = false, drop = false;
675 Error *local_err = NULL;
676 CommonBlockJobCBInfo cbi;
677
678 fmt = NULL;
679 cache = BDRV_DEFAULT_CACHE;
680 base = NULL;
681 for(;;) {
682 c = getopt(argc, argv, "f:ht:b:dpq");
683 if (c == -1) {
684 break;
685 }
686 switch(c) {
687 case '?':
688 case 'h':
689 help();
690 break;
691 case 'f':
692 fmt = optarg;
693 break;
694 case 't':
695 cache = optarg;
696 break;
697 case 'b':
698 base = optarg;
699 /* -b implies -d */
700 drop = true;
701 break;
702 case 'd':
703 drop = true;
704 break;
705 case 'p':
706 progress = true;
707 break;
708 case 'q':
709 quiet = true;
710 break;
711 }
712 }
713
714 /* Progress is not shown in Quiet mode */
715 if (quiet) {
716 progress = false;
717 }
718
719 if (optind != argc - 1) {
720 error_exit("Expecting one image file name");
721 }
722 filename = argv[optind++];
723
724 flags = BDRV_O_RDWR | BDRV_O_UNMAP;
725 ret = bdrv_parse_cache_flags(cache, &flags);
726 if (ret < 0) {
727 error_report("Invalid cache option: %s", cache);
728 return 1;
729 }
730
731 blk = img_open("image", filename, fmt, flags, true, quiet);
732 if (!blk) {
733 return 1;
734 }
735 bs = blk_bs(blk);
736
737 qemu_progress_init(progress, 1.f);
738 qemu_progress_print(0.f, 100);
739
740 if (base) {
741 base_bs = bdrv_find_backing_image(bs, base);
742 if (!base_bs) {
743 error_setg(&local_err, QERR_BASE_NOT_FOUND, base);
744 goto done;
745 }
746 } else {
747 /* This is different from QMP, which by default uses the deepest file in
748 * the backing chain (i.e., the very base); however, the traditional
749 * behavior of qemu-img commit is using the immediate backing file. */
750 base_bs = bs->backing_hd;
751 if (!base_bs) {
752 error_setg(&local_err, "Image does not have a backing file");
753 goto done;
754 }
755 }
756
757 cbi = (CommonBlockJobCBInfo){
758 .errp = &local_err,
759 .bs = bs,
760 };
761
762 commit_active_start(bs, base_bs, 0, BLOCKDEV_ON_ERROR_REPORT,
763 common_block_job_cb, &cbi, &local_err);
764 if (local_err) {
765 goto done;
766 }
767
768 /* The block job will swap base_bs and bs (which is not what we really want
769 * here, but okay) and unref base_bs (after the swap, i.e., the old top
770 * image). In order to still be able to empty that top image afterwards,
771 * increment the reference counter here preemptively. */
772 if (!drop) {
773 bdrv_ref(base_bs);
774 }
775
776 run_block_job(bs->job, &local_err);
777 if (local_err) {
778 goto unref_backing;
779 }
780
781 if (!drop && base_bs->drv->bdrv_make_empty) {
782 ret = base_bs->drv->bdrv_make_empty(base_bs);
783 if (ret) {
784 error_setg_errno(&local_err, -ret, "Could not empty %s",
785 filename);
786 goto unref_backing;
787 }
788 }
789
790 unref_backing:
791 if (!drop) {
792 bdrv_unref(base_bs);
793 }
794
795 done:
796 qemu_progress_end();
797
798 blk_unref(blk);
799
800 if (local_err) {
801 error_report_err(local_err);
802 return 1;
803 }
804
805 qprintf(quiet, "Image committed.\n");
806 return 0;
807 }
808
809 /*
810 * Returns true iff the first sector pointed to by 'buf' contains at least
811 * a non-NUL byte.
812 *
813 * 'pnum' is set to the number of sectors (including and immediately following
814 * the first one) that are known to be in the same allocated/unallocated state.
815 */
816 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
817 {
818 bool is_zero;
819 int i;
820
821 if (n <= 0) {
822 *pnum = 0;
823 return 0;
824 }
825 is_zero = buffer_is_zero(buf, 512);
826 for(i = 1; i < n; i++) {
827 buf += 512;
828 if (is_zero != buffer_is_zero(buf, 512)) {
829 break;
830 }
831 }
832 *pnum = i;
833 return !is_zero;
834 }
835
836 /*
837 * Like is_allocated_sectors, but if the buffer starts with a used sector,
838 * up to 'min' consecutive sectors containing zeros are ignored. This avoids
839 * breaking up write requests for only small sparse areas.
840 */
841 static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
842 int min)
843 {
844 int ret;
845 int num_checked, num_used;
846
847 if (n < min) {
848 min = n;
849 }
850
851 ret = is_allocated_sectors(buf, n, pnum);
852 if (!ret) {
853 return ret;
854 }
855
856 num_used = *pnum;
857 buf += BDRV_SECTOR_SIZE * *pnum;
858 n -= *pnum;
859 num_checked = num_used;
860
861 while (n > 0) {
862 ret = is_allocated_sectors(buf, n, pnum);
863
864 buf += BDRV_SECTOR_SIZE * *pnum;
865 n -= *pnum;
866 num_checked += *pnum;
867 if (ret) {
868 num_used = num_checked;
869 } else if (*pnum >= min) {
870 break;
871 }
872 }
873
874 *pnum = num_used;
875 return 1;
876 }
877
878 /*
879 * Compares two buffers sector by sector. Returns 0 if the first sector of both
880 * buffers matches, non-zero otherwise.
881 *
882 * pnum is set to the number of sectors (including and immediately following
883 * the first one) that are known to have the same comparison result
884 */
885 static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
886 int *pnum)
887 {
888 bool res;
889 int i;
890
891 if (n <= 0) {
892 *pnum = 0;
893 return 0;
894 }
895
896 res = !!memcmp(buf1, buf2, 512);
897 for(i = 1; i < n; i++) {
898 buf1 += 512;
899 buf2 += 512;
900
901 if (!!memcmp(buf1, buf2, 512) != res) {
902 break;
903 }
904 }
905
906 *pnum = i;
907 return res;
908 }
909
910 #define IO_BUF_SIZE (2 * 1024 * 1024)
911
912 static int64_t sectors_to_bytes(int64_t sectors)
913 {
914 return sectors << BDRV_SECTOR_BITS;
915 }
916
917 static int64_t sectors_to_process(int64_t total, int64_t from)
918 {
919 return MIN(total - from, IO_BUF_SIZE >> BDRV_SECTOR_BITS);
920 }
921
922 /*
923 * Check if passed sectors are empty (not allocated or contain only 0 bytes)
924 *
925 * Returns 0 in case sectors are filled with 0, 1 if sectors contain non-zero
926 * data and negative value on error.
927 *
928 * @param blk: BlockBackend for the image
929 * @param sect_num: Number of first sector to check
930 * @param sect_count: Number of sectors to check
931 * @param filename: Name of disk file we are checking (logging purpose)
932 * @param buffer: Allocated buffer for storing read data
933 * @param quiet: Flag for quiet mode
934 */
935 static int check_empty_sectors(BlockBackend *blk, int64_t sect_num,
936 int sect_count, const char *filename,
937 uint8_t *buffer, bool quiet)
938 {
939 int pnum, ret = 0;
940 ret = blk_read(blk, sect_num, buffer, sect_count);
941 if (ret < 0) {
942 error_report("Error while reading offset %" PRId64 " of %s: %s",
943 sectors_to_bytes(sect_num), filename, strerror(-ret));
944 return ret;
945 }
946 ret = is_allocated_sectors(buffer, sect_count, &pnum);
947 if (ret || pnum != sect_count) {
948 qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
949 sectors_to_bytes(ret ? sect_num : sect_num + pnum));
950 return 1;
951 }
952
953 return 0;
954 }
955
956 /*
957 * Compares two images. Exit codes:
958 *
959 * 0 - Images are identical
960 * 1 - Images differ
961 * >1 - Error occurred
962 */
963 static int img_compare(int argc, char **argv)
964 {
965 const char *fmt1 = NULL, *fmt2 = NULL, *cache, *filename1, *filename2;
966 BlockBackend *blk1, *blk2;
967 BlockDriverState *bs1, *bs2;
968 int64_t total_sectors1, total_sectors2;
969 uint8_t *buf1 = NULL, *buf2 = NULL;
970 int pnum1, pnum2;
971 int allocated1, allocated2;
972 int ret = 0; /* return value - 0 Ident, 1 Different, >1 Error */
973 bool progress = false, quiet = false, strict = false;
974 int flags;
975 int64_t total_sectors;
976 int64_t sector_num = 0;
977 int64_t nb_sectors;
978 int c, pnum;
979 uint64_t progress_base;
980
981 cache = BDRV_DEFAULT_CACHE;
982 for (;;) {
983 c = getopt(argc, argv, "hf:F:T:pqs");
984 if (c == -1) {
985 break;
986 }
987 switch (c) {
988 case '?':
989 case 'h':
990 help();
991 break;
992 case 'f':
993 fmt1 = optarg;
994 break;
995 case 'F':
996 fmt2 = optarg;
997 break;
998 case 'T':
999 cache = optarg;
1000 break;
1001 case 'p':
1002 progress = true;
1003 break;
1004 case 'q':
1005 quiet = true;
1006 break;
1007 case 's':
1008 strict = true;
1009 break;
1010 }
1011 }
1012
1013 /* Progress is not shown in Quiet mode */
1014 if (quiet) {
1015 progress = false;
1016 }
1017
1018
1019 if (optind != argc - 2) {
1020 error_exit("Expecting two image file names");
1021 }
1022 filename1 = argv[optind++];
1023 filename2 = argv[optind++];
1024
1025 /* Initialize before goto out */
1026 qemu_progress_init(progress, 2.0);
1027
1028 flags = BDRV_O_FLAGS;
1029 ret = bdrv_parse_cache_flags(cache, &flags);
1030 if (ret < 0) {
1031 error_report("Invalid source cache option: %s", cache);
1032 ret = 2;
1033 goto out3;
1034 }
1035
1036 blk1 = img_open("image_1", filename1, fmt1, flags, true, quiet);
1037 if (!blk1) {
1038 ret = 2;
1039 goto out3;
1040 }
1041 bs1 = blk_bs(blk1);
1042
1043 blk2 = img_open("image_2", filename2, fmt2, flags, true, quiet);
1044 if (!blk2) {
1045 ret = 2;
1046 goto out2;
1047 }
1048 bs2 = blk_bs(blk2);
1049
1050 buf1 = blk_blockalign(blk1, IO_BUF_SIZE);
1051 buf2 = blk_blockalign(blk2, IO_BUF_SIZE);
1052 total_sectors1 = blk_nb_sectors(blk1);
1053 if (total_sectors1 < 0) {
1054 error_report("Can't get size of %s: %s",
1055 filename1, strerror(-total_sectors1));
1056 ret = 4;
1057 goto out;
1058 }
1059 total_sectors2 = blk_nb_sectors(blk2);
1060 if (total_sectors2 < 0) {
1061 error_report("Can't get size of %s: %s",
1062 filename2, strerror(-total_sectors2));
1063 ret = 4;
1064 goto out;
1065 }
1066 total_sectors = MIN(total_sectors1, total_sectors2);
1067 progress_base = MAX(total_sectors1, total_sectors2);
1068
1069 qemu_progress_print(0, 100);
1070
1071 if (strict && total_sectors1 != total_sectors2) {
1072 ret = 1;
1073 qprintf(quiet, "Strict mode: Image size mismatch!\n");
1074 goto out;
1075 }
1076
1077 for (;;) {
1078 nb_sectors = sectors_to_process(total_sectors, sector_num);
1079 if (nb_sectors <= 0) {
1080 break;
1081 }
1082 allocated1 = bdrv_is_allocated_above(bs1, NULL, sector_num, nb_sectors,
1083 &pnum1);
1084 if (allocated1 < 0) {
1085 ret = 3;
1086 error_report("Sector allocation test failed for %s", filename1);
1087 goto out;
1088 }
1089
1090 allocated2 = bdrv_is_allocated_above(bs2, NULL, sector_num, nb_sectors,
1091 &pnum2);
1092 if (allocated2 < 0) {
1093 ret = 3;
1094 error_report("Sector allocation test failed for %s", filename2);
1095 goto out;
1096 }
1097 nb_sectors = MIN(pnum1, pnum2);
1098
1099 if (allocated1 == allocated2) {
1100 if (allocated1) {
1101 ret = blk_read(blk1, sector_num, buf1, nb_sectors);
1102 if (ret < 0) {
1103 error_report("Error while reading offset %" PRId64 " of %s:"
1104 " %s", sectors_to_bytes(sector_num), filename1,
1105 strerror(-ret));
1106 ret = 4;
1107 goto out;
1108 }
1109 ret = blk_read(blk2, sector_num, buf2, nb_sectors);
1110 if (ret < 0) {
1111 error_report("Error while reading offset %" PRId64
1112 " of %s: %s", sectors_to_bytes(sector_num),
1113 filename2, strerror(-ret));
1114 ret = 4;
1115 goto out;
1116 }
1117 ret = compare_sectors(buf1, buf2, nb_sectors, &pnum);
1118 if (ret || pnum != nb_sectors) {
1119 qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
1120 sectors_to_bytes(
1121 ret ? sector_num : sector_num + pnum));
1122 ret = 1;
1123 goto out;
1124 }
1125 }
1126 } else {
1127 if (strict) {
1128 ret = 1;
1129 qprintf(quiet, "Strict mode: Offset %" PRId64
1130 " allocation mismatch!\n",
1131 sectors_to_bytes(sector_num));
1132 goto out;
1133 }
1134
1135 if (allocated1) {
1136 ret = check_empty_sectors(blk1, sector_num, nb_sectors,
1137 filename1, buf1, quiet);
1138 } else {
1139 ret = check_empty_sectors(blk2, sector_num, nb_sectors,
1140 filename2, buf1, quiet);
1141 }
1142 if (ret) {
1143 if (ret < 0) {
1144 error_report("Error while reading offset %" PRId64 ": %s",
1145 sectors_to_bytes(sector_num), strerror(-ret));
1146 ret = 4;
1147 }
1148 goto out;
1149 }
1150 }
1151 sector_num += nb_sectors;
1152 qemu_progress_print(((float) nb_sectors / progress_base)*100, 100);
1153 }
1154
1155 if (total_sectors1 != total_sectors2) {
1156 BlockBackend *blk_over;
1157 int64_t total_sectors_over;
1158 const char *filename_over;
1159
1160 qprintf(quiet, "Warning: Image size mismatch!\n");
1161 if (total_sectors1 > total_sectors2) {
1162 total_sectors_over = total_sectors1;
1163 blk_over = blk1;
1164 filename_over = filename1;
1165 } else {
1166 total_sectors_over = total_sectors2;
1167 blk_over = blk2;
1168 filename_over = filename2;
1169 }
1170
1171 for (;;) {
1172 nb_sectors = sectors_to_process(total_sectors_over, sector_num);
1173 if (nb_sectors <= 0) {
1174 break;
1175 }
1176 ret = bdrv_is_allocated_above(blk_bs(blk_over), NULL, sector_num,
1177 nb_sectors, &pnum);
1178 if (ret < 0) {
1179 ret = 3;
1180 error_report("Sector allocation test failed for %s",
1181 filename_over);
1182 goto out;
1183
1184 }
1185 nb_sectors = pnum;
1186 if (ret) {
1187 ret = check_empty_sectors(blk_over, sector_num, nb_sectors,
1188 filename_over, buf1, quiet);
1189 if (ret) {
1190 if (ret < 0) {
1191 error_report("Error while reading offset %" PRId64
1192 " of %s: %s", sectors_to_bytes(sector_num),
1193 filename_over, strerror(-ret));
1194 ret = 4;
1195 }
1196 goto out;
1197 }
1198 }
1199 sector_num += nb_sectors;
1200 qemu_progress_print(((float) nb_sectors / progress_base)*100, 100);
1201 }
1202 }
1203
1204 qprintf(quiet, "Images are identical.\n");
1205 ret = 0;
1206
1207 out:
1208 qemu_vfree(buf1);
1209 qemu_vfree(buf2);
1210 blk_unref(blk2);
1211 out2:
1212 blk_unref(blk1);
1213 out3:
1214 qemu_progress_end();
1215 return ret;
1216 }
1217
1218 enum ImgConvertBlockStatus {
1219 BLK_DATA,
1220 BLK_ZERO,
1221 BLK_BACKING_FILE,
1222 };
1223
1224 typedef struct ImgConvertState {
1225 BlockBackend **src;
1226 int64_t *src_sectors;
1227 int src_cur, src_num;
1228 int64_t src_cur_offset;
1229 int64_t total_sectors;
1230 int64_t allocated_sectors;
1231 enum ImgConvertBlockStatus status;
1232 int64_t sector_next_status;
1233 BlockBackend *target;
1234 bool has_zero_init;
1235 bool compressed;
1236 bool target_has_backing;
1237 int min_sparse;
1238 size_t cluster_sectors;
1239 size_t buf_sectors;
1240 } ImgConvertState;
1241
1242 static void convert_select_part(ImgConvertState *s, int64_t sector_num)
1243 {
1244 assert(sector_num >= s->src_cur_offset);
1245 while (sector_num - s->src_cur_offset >= s->src_sectors[s->src_cur]) {
1246 s->src_cur_offset += s->src_sectors[s->src_cur];
1247 s->src_cur++;
1248 assert(s->src_cur < s->src_num);
1249 }
1250 }
1251
1252 static int convert_iteration_sectors(ImgConvertState *s, int64_t sector_num)
1253 {
1254 int64_t ret;
1255 int n;
1256
1257 convert_select_part(s, sector_num);
1258
1259 assert(s->total_sectors > sector_num);
1260 n = MIN(s->total_sectors - sector_num, BDRV_REQUEST_MAX_SECTORS);
1261
1262 if (s->sector_next_status <= sector_num) {
1263 ret = bdrv_get_block_status(blk_bs(s->src[s->src_cur]),
1264 sector_num - s->src_cur_offset,
1265 n, &n);
1266 if (ret < 0) {
1267 return ret;
1268 }
1269
1270 if (ret & BDRV_BLOCK_ZERO) {
1271 s->status = BLK_ZERO;
1272 } else if (ret & BDRV_BLOCK_DATA) {
1273 s->status = BLK_DATA;
1274 } else if (!s->target_has_backing) {
1275 /* Without a target backing file we must copy over the contents of
1276 * the backing file as well. */
1277 /* TODO Check block status of the backing file chain to avoid
1278 * needlessly reading zeroes and limiting the iteration to the
1279 * buffer size */
1280 s->status = BLK_DATA;
1281 } else {
1282 s->status = BLK_BACKING_FILE;
1283 }
1284
1285 s->sector_next_status = sector_num + n;
1286 }
1287
1288 n = MIN(n, s->sector_next_status - sector_num);
1289 if (s->status == BLK_DATA) {
1290 n = MIN(n, s->buf_sectors);
1291 }
1292
1293 /* We need to write complete clusters for compressed images, so if an
1294 * unallocated area is shorter than that, we must consider the whole
1295 * cluster allocated. */
1296 if (s->compressed) {
1297 if (n < s->cluster_sectors) {
1298 n = MIN(s->cluster_sectors, s->total_sectors - sector_num);
1299 s->status = BLK_DATA;
1300 } else {
1301 n = QEMU_ALIGN_DOWN(n, s->cluster_sectors);
1302 }
1303 }
1304
1305 return n;
1306 }
1307
1308 static int convert_read(ImgConvertState *s, int64_t sector_num, int nb_sectors,
1309 uint8_t *buf)
1310 {
1311 int n;
1312 int ret;
1313
1314 if (s->status == BLK_ZERO || s->status == BLK_BACKING_FILE) {
1315 return 0;
1316 }
1317
1318 assert(nb_sectors <= s->buf_sectors);
1319 while (nb_sectors > 0) {
1320 BlockBackend *blk;
1321 int64_t bs_sectors;
1322
1323 /* In the case of compression with multiple source files, we can get a
1324 * nb_sectors that spreads into the next part. So we must be able to
1325 * read across multiple BDSes for one convert_read() call. */
1326 convert_select_part(s, sector_num);
1327 blk = s->src[s->src_cur];
1328 bs_sectors = s->src_sectors[s->src_cur];
1329
1330 n = MIN(nb_sectors, bs_sectors - (sector_num - s->src_cur_offset));
1331 ret = blk_read(blk, sector_num - s->src_cur_offset, buf, n);
1332 if (ret < 0) {
1333 return ret;
1334 }
1335
1336 sector_num += n;
1337 nb_sectors -= n;
1338 buf += n * BDRV_SECTOR_SIZE;
1339 }
1340
1341 return 0;
1342 }
1343
1344 static int convert_write(ImgConvertState *s, int64_t sector_num, int nb_sectors,
1345 const uint8_t *buf)
1346 {
1347 int ret;
1348
1349 while (nb_sectors > 0) {
1350 int n = nb_sectors;
1351
1352 switch (s->status) {
1353 case BLK_BACKING_FILE:
1354 /* If we have a backing file, leave clusters unallocated that are
1355 * unallocated in the source image, so that the backing file is
1356 * visible at the respective offset. */
1357 assert(s->target_has_backing);
1358 break;
1359
1360 case BLK_DATA:
1361 /* We must always write compressed clusters as a whole, so don't
1362 * try to find zeroed parts in the buffer. We can only save the
1363 * write if the buffer is completely zeroed and we're allowed to
1364 * keep the target sparse. */
1365 if (s->compressed) {
1366 if (s->has_zero_init && s->min_sparse &&
1367 buffer_is_zero(buf, n * BDRV_SECTOR_SIZE))
1368 {
1369 assert(!s->target_has_backing);
1370 break;
1371 }
1372
1373 ret = blk_write_compressed(s->target, sector_num, buf, n);
1374 if (ret < 0) {
1375 return ret;
1376 }
1377 break;
1378 }
1379
1380 /* If there is real non-zero data or we're told to keep the target
1381 * fully allocated (-S 0), we must write it. Otherwise we can treat
1382 * it as zero sectors. */
1383 if (!s->min_sparse ||
1384 is_allocated_sectors_min(buf, n, &n, s->min_sparse))
1385 {
1386 ret = blk_write(s->target, sector_num, buf, n);
1387 if (ret < 0) {
1388 return ret;
1389 }
1390 break;
1391 }
1392 /* fall-through */
1393
1394 case BLK_ZERO:
1395 if (s->has_zero_init) {
1396 break;
1397 }
1398 ret = blk_write_zeroes(s->target, sector_num, n, 0);
1399 if (ret < 0) {
1400 return ret;
1401 }
1402 break;
1403 }
1404
1405 sector_num += n;
1406 nb_sectors -= n;
1407 buf += n * BDRV_SECTOR_SIZE;
1408 }
1409
1410 return 0;
1411 }
1412
1413 static int convert_do_copy(ImgConvertState *s)
1414 {
1415 uint8_t *buf = NULL;
1416 int64_t sector_num, allocated_done;
1417 int ret;
1418 int n;
1419
1420 /* Check whether we have zero initialisation or can get it efficiently */
1421 s->has_zero_init = s->min_sparse && !s->target_has_backing
1422 ? bdrv_has_zero_init(blk_bs(s->target))
1423 : false;
1424
1425 if (!s->has_zero_init && !s->target_has_backing &&
1426 bdrv_can_write_zeroes_with_unmap(blk_bs(s->target)))
1427 {
1428 ret = bdrv_make_zero(blk_bs(s->target), BDRV_REQ_MAY_UNMAP);
1429 if (ret == 0) {
1430 s->has_zero_init = true;
1431 }
1432 }
1433
1434 /* Allocate buffer for copied data. For compressed images, only one cluster
1435 * can be copied at a time. */
1436 if (s->compressed) {
1437 if (s->cluster_sectors <= 0 || s->cluster_sectors > s->buf_sectors) {
1438 error_report("invalid cluster size");
1439 ret = -EINVAL;
1440 goto fail;
1441 }
1442 s->buf_sectors = s->cluster_sectors;
1443 }
1444 buf = blk_blockalign(s->target, s->buf_sectors * BDRV_SECTOR_SIZE);
1445
1446 /* Calculate allocated sectors for progress */
1447 s->allocated_sectors = 0;
1448 sector_num = 0;
1449 while (sector_num < s->total_sectors) {
1450 n = convert_iteration_sectors(s, sector_num);
1451 if (n < 0) {
1452 ret = n;
1453 goto fail;
1454 }
1455 if (s->status == BLK_DATA) {
1456 s->allocated_sectors += n;
1457 }
1458 sector_num += n;
1459 }
1460
1461 /* Do the copy */
1462 s->src_cur = 0;
1463 s->src_cur_offset = 0;
1464 s->sector_next_status = 0;
1465
1466 sector_num = 0;
1467 allocated_done = 0;
1468
1469 while (sector_num < s->total_sectors) {
1470 n = convert_iteration_sectors(s, sector_num);
1471 if (n < 0) {
1472 ret = n;
1473 goto fail;
1474 }
1475 if (s->status == BLK_DATA) {
1476 allocated_done += n;
1477 qemu_progress_print(100.0 * allocated_done / s->allocated_sectors,
1478 0);
1479 }
1480
1481 ret = convert_read(s, sector_num, n, buf);
1482 if (ret < 0) {
1483 error_report("error while reading sector %" PRId64
1484 ": %s", sector_num, strerror(-ret));
1485 goto fail;
1486 }
1487
1488 ret = convert_write(s, sector_num, n, buf);
1489 if (ret < 0) {
1490 error_report("error while writing sector %" PRId64
1491 ": %s", sector_num, strerror(-ret));
1492 goto fail;
1493 }
1494
1495 sector_num += n;
1496 }
1497
1498 if (s->compressed) {
1499 /* signal EOF to align */
1500 ret = blk_write_compressed(s->target, 0, NULL, 0);
1501 if (ret < 0) {
1502 goto fail;
1503 }
1504 }
1505
1506 ret = 0;
1507 fail:
1508 qemu_vfree(buf);
1509 return ret;
1510 }
1511
1512 static int img_convert(int argc, char **argv)
1513 {
1514 int c, bs_n, bs_i, compress, cluster_sectors, skip_create;
1515 int64_t ret = 0;
1516 int progress = 0, flags, src_flags;
1517 const char *fmt, *out_fmt, *cache, *src_cache, *out_baseimg, *out_filename;
1518 BlockDriver *drv, *proto_drv;
1519 BlockBackend **blk = NULL, *out_blk = NULL;
1520 BlockDriverState **bs = NULL, *out_bs = NULL;
1521 int64_t total_sectors;
1522 int64_t *bs_sectors = NULL;
1523 size_t bufsectors = IO_BUF_SIZE / BDRV_SECTOR_SIZE;
1524 BlockDriverInfo bdi;
1525 QemuOpts *opts = NULL;
1526 QemuOptsList *create_opts = NULL;
1527 const char *out_baseimg_param;
1528 char *options = NULL;
1529 const char *snapshot_name = NULL;
1530 int min_sparse = 8; /* Need at least 4k of zeros for sparse detection */
1531 bool quiet = false;
1532 Error *local_err = NULL;
1533 QemuOpts *sn_opts = NULL;
1534 ImgConvertState state;
1535
1536 fmt = NULL;
1537 out_fmt = "raw";
1538 cache = "unsafe";
1539 src_cache = BDRV_DEFAULT_CACHE;
1540 out_baseimg = NULL;
1541 compress = 0;
1542 skip_create = 0;
1543 for(;;) {
1544 c = getopt(argc, argv, "hf:O:B:ce6o:s:l:S:pt:T:qn");
1545 if (c == -1) {
1546 break;
1547 }
1548 switch(c) {
1549 case '?':
1550 case 'h':
1551 help();
1552 break;
1553 case 'f':
1554 fmt = optarg;
1555 break;
1556 case 'O':
1557 out_fmt = optarg;
1558 break;
1559 case 'B':
1560 out_baseimg = optarg;
1561 break;
1562 case 'c':
1563 compress = 1;
1564 break;
1565 case 'e':
1566 error_report("option -e is deprecated, please use \'-o "
1567 "encryption\' instead!");
1568 ret = -1;
1569 goto fail_getopt;
1570 case '6':
1571 error_report("option -6 is deprecated, please use \'-o "
1572 "compat6\' instead!");
1573 ret = -1;
1574 goto fail_getopt;
1575 case 'o':
1576 if (!is_valid_option_list(optarg)) {
1577 error_report("Invalid option list: %s", optarg);
1578 ret = -1;
1579 goto fail_getopt;
1580 }
1581 if (!options) {
1582 options = g_strdup(optarg);
1583 } else {
1584 char *old_options = options;
1585 options = g_strdup_printf("%s,%s", options, optarg);
1586 g_free(old_options);
1587 }
1588 break;
1589 case 's':
1590 snapshot_name = optarg;
1591 break;
1592 case 'l':
1593 if (strstart(optarg, SNAPSHOT_OPT_BASE, NULL)) {
1594 sn_opts = qemu_opts_parse_noisily(&internal_snapshot_opts,
1595 optarg, false);
1596 if (!sn_opts) {
1597 error_report("Failed in parsing snapshot param '%s'",
1598 optarg);
1599 ret = -1;
1600 goto fail_getopt;
1601 }
1602 } else {
1603 snapshot_name = optarg;
1604 }
1605 break;
1606 case 'S':
1607 {
1608 int64_t sval;
1609 char *end;
1610 sval = strtosz_suffix(optarg, &end, STRTOSZ_DEFSUFFIX_B);
1611 if (sval < 0 || *end) {
1612 error_report("Invalid minimum zero buffer size for sparse output specified");
1613 ret = -1;
1614 goto fail_getopt;
1615 }
1616
1617 min_sparse = sval / BDRV_SECTOR_SIZE;
1618 break;
1619 }
1620 case 'p':
1621 progress = 1;
1622 break;
1623 case 't':
1624 cache = optarg;
1625 break;
1626 case 'T':
1627 src_cache = optarg;
1628 break;
1629 case 'q':
1630 quiet = true;
1631 break;
1632 case 'n':
1633 skip_create = 1;
1634 break;
1635 }
1636 }
1637
1638 /* Initialize before goto out */
1639 if (quiet) {
1640 progress = 0;
1641 }
1642 qemu_progress_init(progress, 1.0);
1643
1644
1645 bs_n = argc - optind - 1;
1646 out_filename = bs_n >= 1 ? argv[argc - 1] : NULL;
1647
1648 if (options && has_help_option(options)) {
1649 ret = print_block_option_help(out_filename, out_fmt);
1650 goto out;
1651 }
1652
1653 if (bs_n < 1) {
1654 error_exit("Must specify image file name");
1655 }
1656
1657
1658 if (bs_n > 1 && out_baseimg) {
1659 error_report("-B makes no sense when concatenating multiple input "
1660 "images");
1661 ret = -1;
1662 goto out;
1663 }
1664
1665 src_flags = BDRV_O_FLAGS;
1666 ret = bdrv_parse_cache_flags(src_cache, &src_flags);
1667 if (ret < 0) {
1668 error_report("Invalid source cache option: %s", src_cache);
1669 goto out;
1670 }
1671
1672 qemu_progress_print(0, 100);
1673
1674 blk = g_new0(BlockBackend *, bs_n);
1675 bs = g_new0(BlockDriverState *, bs_n);
1676 bs_sectors = g_new(int64_t, bs_n);
1677
1678 total_sectors = 0;
1679 for (bs_i = 0; bs_i < bs_n; bs_i++) {
1680 char *id = bs_n > 1 ? g_strdup_printf("source_%d", bs_i)
1681 : g_strdup("source");
1682 blk[bs_i] = img_open(id, argv[optind + bs_i], fmt, src_flags,
1683 true, quiet);
1684 g_free(id);
1685 if (!blk[bs_i]) {
1686 ret = -1;
1687 goto out;
1688 }
1689 bs[bs_i] = blk_bs(blk[bs_i]);
1690 bs_sectors[bs_i] = blk_nb_sectors(blk[bs_i]);
1691 if (bs_sectors[bs_i] < 0) {
1692 error_report("Could not get size of %s: %s",
1693 argv[optind + bs_i], strerror(-bs_sectors[bs_i]));
1694 ret = -1;
1695 goto out;
1696 }
1697 total_sectors += bs_sectors[bs_i];
1698 }
1699
1700 if (sn_opts) {
1701 ret = bdrv_snapshot_load_tmp(bs[0],
1702 qemu_opt_get(sn_opts, SNAPSHOT_OPT_ID),
1703 qemu_opt_get(sn_opts, SNAPSHOT_OPT_NAME),
1704 &local_err);
1705 } else if (snapshot_name != NULL) {
1706 if (bs_n > 1) {
1707 error_report("No support for concatenating multiple snapshot");
1708 ret = -1;
1709 goto out;
1710 }
1711
1712 bdrv_snapshot_load_tmp_by_id_or_name(bs[0], snapshot_name, &local_err);
1713 }
1714 if (local_err) {
1715 error_report("Failed to load snapshot: %s",
1716 error_get_pretty(local_err));
1717 error_free(local_err);
1718 ret = -1;
1719 goto out;
1720 }
1721
1722 /* Find driver and parse its options */
1723 drv = bdrv_find_format(out_fmt);
1724 if (!drv) {
1725 error_report("Unknown file format '%s'", out_fmt);
1726 ret = -1;
1727 goto out;
1728 }
1729
1730 proto_drv = bdrv_find_protocol(out_filename, true, &local_err);
1731 if (!proto_drv) {
1732 error_report_err(local_err);
1733 ret = -1;
1734 goto out;
1735 }
1736
1737 if (!skip_create) {
1738 if (!drv->create_opts) {
1739 error_report("Format driver '%s' does not support image creation",
1740 drv->format_name);
1741 ret = -1;
1742 goto out;
1743 }
1744
1745 if (!proto_drv->create_opts) {
1746 error_report("Protocol driver '%s' does not support image creation",
1747 proto_drv->format_name);
1748 ret = -1;
1749 goto out;
1750 }
1751
1752 create_opts = qemu_opts_append(create_opts, drv->create_opts);
1753 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
1754
1755 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
1756 if (options) {
1757 qemu_opts_do_parse(opts, options, NULL, &local_err);
1758 if (local_err) {
1759 error_report_err(local_err);
1760 ret = -1;
1761 goto out;
1762 }
1763 }
1764
1765 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_sectors * 512,
1766 &error_abort);
1767 ret = add_old_style_options(out_fmt, opts, out_baseimg, NULL);
1768 if (ret < 0) {
1769 goto out;
1770 }
1771 }
1772
1773 /* Get backing file name if -o backing_file was used */
1774 out_baseimg_param = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
1775 if (out_baseimg_param) {
1776 out_baseimg = out_baseimg_param;
1777 }
1778
1779 /* Check if compression is supported */
1780 if (compress) {
1781 bool encryption =
1782 qemu_opt_get_bool(opts, BLOCK_OPT_ENCRYPT, false);
1783 const char *preallocation =
1784 qemu_opt_get(opts, BLOCK_OPT_PREALLOC);
1785
1786 if (!drv->bdrv_write_compressed) {
1787 error_report("Compression not supported for this file format");
1788 ret = -1;
1789 goto out;
1790 }
1791
1792 if (encryption) {
1793 error_report("Compression and encryption not supported at "
1794 "the same time");
1795 ret = -1;
1796 goto out;
1797 }
1798
1799 if (preallocation
1800 && strcmp(preallocation, "off"))
1801 {
1802 error_report("Compression and preallocation not supported at "
1803 "the same time");
1804 ret = -1;
1805 goto out;
1806 }
1807 }
1808
1809 if (!skip_create) {
1810 /* Create the new image */
1811 ret = bdrv_create(drv, out_filename, opts, &local_err);
1812 if (ret < 0) {
1813 error_report("%s: error while converting %s: %s",
1814 out_filename, out_fmt, error_get_pretty(local_err));
1815 error_free(local_err);
1816 goto out;
1817 }
1818 }
1819
1820 flags = min_sparse ? (BDRV_O_RDWR | BDRV_O_UNMAP) : BDRV_O_RDWR;
1821 ret = bdrv_parse_cache_flags(cache, &flags);
1822 if (ret < 0) {
1823 error_report("Invalid cache option: %s", cache);
1824 goto out;
1825 }
1826
1827 out_blk = img_open("target", out_filename, out_fmt, flags, true, quiet);
1828 if (!out_blk) {
1829 ret = -1;
1830 goto out;
1831 }
1832 out_bs = blk_bs(out_blk);
1833
1834 /* increase bufsectors from the default 4096 (2M) if opt_transfer_length
1835 * or discard_alignment of the out_bs is greater. Limit to 32768 (16MB)
1836 * as maximum. */
1837 bufsectors = MIN(32768,
1838 MAX(bufsectors, MAX(out_bs->bl.opt_transfer_length,
1839 out_bs->bl.discard_alignment))
1840 );
1841
1842 if (skip_create) {
1843 int64_t output_sectors = blk_nb_sectors(out_blk);
1844 if (output_sectors < 0) {
1845 error_report("unable to get output image length: %s",
1846 strerror(-output_sectors));
1847 ret = -1;
1848 goto out;
1849 } else if (output_sectors < total_sectors) {
1850 error_report("output file is smaller than input file");
1851 ret = -1;
1852 goto out;
1853 }
1854 }
1855
1856 cluster_sectors = 0;
1857 ret = bdrv_get_info(out_bs, &bdi);
1858 if (ret < 0) {
1859 if (compress) {
1860 error_report("could not get block driver info");
1861 goto out;
1862 }
1863 } else {
1864 compress = compress || bdi.needs_compressed_writes;
1865 cluster_sectors = bdi.cluster_size / BDRV_SECTOR_SIZE;
1866 }
1867
1868 state = (ImgConvertState) {
1869 .src = blk,
1870 .src_sectors = bs_sectors,
1871 .src_num = bs_n,
1872 .total_sectors = total_sectors,
1873 .target = out_blk,
1874 .compressed = compress,
1875 .target_has_backing = (bool) out_baseimg,
1876 .min_sparse = min_sparse,
1877 .cluster_sectors = cluster_sectors,
1878 .buf_sectors = bufsectors,
1879 };
1880 ret = convert_do_copy(&state);
1881
1882 out:
1883 if (!ret) {
1884 qemu_progress_print(100, 0);
1885 }
1886 qemu_progress_end();
1887 qemu_opts_del(opts);
1888 qemu_opts_free(create_opts);
1889 qemu_opts_del(sn_opts);
1890 blk_unref(out_blk);
1891 g_free(bs);
1892 if (blk) {
1893 for (bs_i = 0; bs_i < bs_n; bs_i++) {
1894 blk_unref(blk[bs_i]);
1895 }
1896 g_free(blk);
1897 }
1898 g_free(bs_sectors);
1899 fail_getopt:
1900 g_free(options);
1901
1902 if (ret) {
1903 return 1;
1904 }
1905 return 0;
1906 }
1907
1908
1909 static void dump_snapshots(BlockDriverState *bs)
1910 {
1911 QEMUSnapshotInfo *sn_tab, *sn;
1912 int nb_sns, i;
1913
1914 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1915 if (nb_sns <= 0)
1916 return;
1917 printf("Snapshot list:\n");
1918 bdrv_snapshot_dump(fprintf, stdout, NULL);
1919 printf("\n");
1920 for(i = 0; i < nb_sns; i++) {
1921 sn = &sn_tab[i];
1922 bdrv_snapshot_dump(fprintf, stdout, sn);
1923 printf("\n");
1924 }
1925 g_free(sn_tab);
1926 }
1927
1928 static void dump_json_image_info_list(ImageInfoList *list)
1929 {
1930 Error *local_err = NULL;
1931 QString *str;
1932 QmpOutputVisitor *ov = qmp_output_visitor_new();
1933 QObject *obj;
1934 visit_type_ImageInfoList(qmp_output_get_visitor(ov),
1935 &list, NULL, &local_err);
1936 obj = qmp_output_get_qobject(ov);
1937 str = qobject_to_json_pretty(obj);
1938 assert(str != NULL);
1939 printf("%s\n", qstring_get_str(str));
1940 qobject_decref(obj);
1941 qmp_output_visitor_cleanup(ov);
1942 QDECREF(str);
1943 }
1944
1945 static void dump_json_image_info(ImageInfo *info)
1946 {
1947 Error *local_err = NULL;
1948 QString *str;
1949 QmpOutputVisitor *ov = qmp_output_visitor_new();
1950 QObject *obj;
1951 visit_type_ImageInfo(qmp_output_get_visitor(ov),
1952 &info, NULL, &local_err);
1953 obj = qmp_output_get_qobject(ov);
1954 str = qobject_to_json_pretty(obj);
1955 assert(str != NULL);
1956 printf("%s\n", qstring_get_str(str));
1957 qobject_decref(obj);
1958 qmp_output_visitor_cleanup(ov);
1959 QDECREF(str);
1960 }
1961
1962 static void dump_human_image_info_list(ImageInfoList *list)
1963 {
1964 ImageInfoList *elem;
1965 bool delim = false;
1966
1967 for (elem = list; elem; elem = elem->next) {
1968 if (delim) {
1969 printf("\n");
1970 }
1971 delim = true;
1972
1973 bdrv_image_info_dump(fprintf, stdout, elem->value);
1974 }
1975 }
1976
1977 static gboolean str_equal_func(gconstpointer a, gconstpointer b)
1978 {
1979 return strcmp(a, b) == 0;
1980 }
1981
1982 /**
1983 * Open an image file chain and return an ImageInfoList
1984 *
1985 * @filename: topmost image filename
1986 * @fmt: topmost image format (may be NULL to autodetect)
1987 * @chain: true - enumerate entire backing file chain
1988 * false - only topmost image file
1989 *
1990 * Returns a list of ImageInfo objects or NULL if there was an error opening an
1991 * image file. If there was an error a message will have been printed to
1992 * stderr.
1993 */
1994 static ImageInfoList *collect_image_info_list(const char *filename,
1995 const char *fmt,
1996 bool chain)
1997 {
1998 ImageInfoList *head = NULL;
1999 ImageInfoList **last = &head;
2000 GHashTable *filenames;
2001 Error *err = NULL;
2002
2003 filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL);
2004
2005 while (filename) {
2006 BlockBackend *blk;
2007 BlockDriverState *bs;
2008 ImageInfo *info;
2009 ImageInfoList *elem;
2010
2011 if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) {
2012 error_report("Backing file '%s' creates an infinite loop.",
2013 filename);
2014 goto err;
2015 }
2016 g_hash_table_insert(filenames, (gpointer)filename, NULL);
2017
2018 blk = img_open("image", filename, fmt,
2019 BDRV_O_FLAGS | BDRV_O_NO_BACKING, false, false);
2020 if (!blk) {
2021 goto err;
2022 }
2023 bs = blk_bs(blk);
2024
2025 bdrv_query_image_info(bs, &info, &err);
2026 if (err) {
2027 error_report_err(err);
2028 blk_unref(blk);
2029 goto err;
2030 }
2031
2032 elem = g_new0(ImageInfoList, 1);
2033 elem->value = info;
2034 *last = elem;
2035 last = &elem->next;
2036
2037 blk_unref(blk);
2038
2039 filename = fmt = NULL;
2040 if (chain) {
2041 if (info->has_full_backing_filename) {
2042 filename = info->full_backing_filename;
2043 } else if (info->has_backing_filename) {
2044 filename = info->backing_filename;
2045 }
2046 if (info->has_backing_filename_format) {
2047 fmt = info->backing_filename_format;
2048 }
2049 }
2050 }
2051 g_hash_table_destroy(filenames);
2052 return head;
2053
2054 err:
2055 qapi_free_ImageInfoList(head);
2056 g_hash_table_destroy(filenames);
2057 return NULL;
2058 }
2059
2060 static int img_info(int argc, char **argv)
2061 {
2062 int c;
2063 OutputFormat output_format = OFORMAT_HUMAN;
2064 bool chain = false;
2065 const char *filename, *fmt, *output;
2066 ImageInfoList *list;
2067
2068 fmt = NULL;
2069 output = NULL;
2070 for(;;) {
2071 int option_index = 0;
2072 static const struct option long_options[] = {
2073 {"help", no_argument, 0, 'h'},
2074 {"format", required_argument, 0, 'f'},
2075 {"output", required_argument, 0, OPTION_OUTPUT},
2076 {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN},
2077 {0, 0, 0, 0}
2078 };
2079 c = getopt_long(argc, argv, "f:h",
2080 long_options, &option_index);
2081 if (c == -1) {
2082 break;
2083 }
2084 switch(c) {
2085 case '?':
2086 case 'h':
2087 help();
2088 break;
2089 case 'f':
2090 fmt = optarg;
2091 break;
2092 case OPTION_OUTPUT:
2093 output = optarg;
2094 break;
2095 case OPTION_BACKING_CHAIN:
2096 chain = true;
2097 break;
2098 }
2099 }
2100 if (optind != argc - 1) {
2101 error_exit("Expecting one image file name");
2102 }
2103 filename = argv[optind++];
2104
2105 if (output && !strcmp(output, "json")) {
2106 output_format = OFORMAT_JSON;
2107 } else if (output && !strcmp(output, "human")) {
2108 output_format = OFORMAT_HUMAN;
2109 } else if (output) {
2110 error_report("--output must be used with human or json as argument.");
2111 return 1;
2112 }
2113
2114 list = collect_image_info_list(filename, fmt, chain);
2115 if (!list) {
2116 return 1;
2117 }
2118
2119 switch (output_format) {
2120 case OFORMAT_HUMAN:
2121 dump_human_image_info_list(list);
2122 break;
2123 case OFORMAT_JSON:
2124 if (chain) {
2125 dump_json_image_info_list(list);
2126 } else {
2127 dump_json_image_info(list->value);
2128 }
2129 break;
2130 }
2131
2132 qapi_free_ImageInfoList(list);
2133 return 0;
2134 }
2135
2136
2137 typedef struct MapEntry {
2138 int flags;
2139 int depth;
2140 int64_t start;
2141 int64_t length;
2142 int64_t offset;
2143 BlockDriverState *bs;
2144 } MapEntry;
2145
2146 static void dump_map_entry(OutputFormat output_format, MapEntry *e,
2147 MapEntry *next)
2148 {
2149 switch (output_format) {
2150 case OFORMAT_HUMAN:
2151 if ((e->flags & BDRV_BLOCK_DATA) &&
2152 !(e->flags & BDRV_BLOCK_OFFSET_VALID)) {
2153 error_report("File contains external, encrypted or compressed clusters.");
2154 exit(1);
2155 }
2156 if ((e->flags & (BDRV_BLOCK_DATA|BDRV_BLOCK_ZERO)) == BDRV_BLOCK_DATA) {
2157 printf("%#-16"PRIx64"%#-16"PRIx64"%#-16"PRIx64"%s\n",
2158 e->start, e->length, e->offset, e->bs->filename);
2159 }
2160 /* This format ignores the distinction between 0, ZERO and ZERO|DATA.
2161 * Modify the flags here to allow more coalescing.
2162 */
2163 if (next &&
2164 (next->flags & (BDRV_BLOCK_DATA|BDRV_BLOCK_ZERO)) != BDRV_BLOCK_DATA) {
2165 next->flags &= ~BDRV_BLOCK_DATA;
2166 next->flags |= BDRV_BLOCK_ZERO;
2167 }
2168 break;
2169 case OFORMAT_JSON:
2170 printf("%s{ \"start\": %"PRId64", \"length\": %"PRId64", \"depth\": %d,"
2171 " \"zero\": %s, \"data\": %s",
2172 (e->start == 0 ? "[" : ",\n"),
2173 e->start, e->length, e->depth,
2174 (e->flags & BDRV_BLOCK_ZERO) ? "true" : "false",
2175 (e->flags & BDRV_BLOCK_DATA) ? "true" : "false");
2176 if (e->flags & BDRV_BLOCK_OFFSET_VALID) {
2177 printf(", \"offset\": %"PRId64"", e->offset);
2178 }
2179 putchar('}');
2180
2181 if (!next) {
2182 printf("]\n");
2183 }
2184 break;
2185 }
2186 }
2187
2188 static int get_block_status(BlockDriverState *bs, int64_t sector_num,
2189 int nb_sectors, MapEntry *e)
2190 {
2191 int64_t ret;
2192 int depth;
2193
2194 /* As an optimization, we could cache the current range of unallocated
2195 * clusters in each file of the chain, and avoid querying the same
2196 * range repeatedly.
2197 */
2198
2199 depth = 0;
2200 for (;;) {
2201 ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &nb_sectors);
2202 if (ret < 0) {
2203 return ret;
2204 }
2205 assert(nb_sectors);
2206 if (ret & (BDRV_BLOCK_ZERO|BDRV_BLOCK_DATA)) {
2207 break;
2208 }
2209 bs = bs->backing_hd;
2210 if (bs == NULL) {
2211 ret = 0;
2212 break;
2213 }
2214
2215 depth++;
2216 }
2217
2218 e->start = sector_num * BDRV_SECTOR_SIZE;
2219 e->length = nb_sectors * BDRV_SECTOR_SIZE;
2220 e->flags = ret & ~BDRV_BLOCK_OFFSET_MASK;
2221 e->offset = ret & BDRV_BLOCK_OFFSET_MASK;
2222 e->depth = depth;
2223 e->bs = bs;
2224 return 0;
2225 }
2226
2227 static int img_map(int argc, char **argv)
2228 {
2229 int c;
2230 OutputFormat output_format = OFORMAT_HUMAN;
2231 BlockBackend *blk;
2232 BlockDriverState *bs;
2233 const char *filename, *fmt, *output;
2234 int64_t length;
2235 MapEntry curr = { .length = 0 }, next;
2236 int ret = 0;
2237
2238 fmt = NULL;
2239 output = NULL;
2240 for (;;) {
2241 int option_index = 0;
2242 static const struct option long_options[] = {
2243 {"help", no_argument, 0, 'h'},
2244 {"format", required_argument, 0, 'f'},
2245 {"output", required_argument, 0, OPTION_OUTPUT},
2246 {0, 0, 0, 0}
2247 };
2248 c = getopt_long(argc, argv, "f:h",
2249 long_options, &option_index);
2250 if (c == -1) {
2251 break;
2252 }
2253 switch (c) {
2254 case '?':
2255 case 'h':
2256 help();
2257 break;
2258 case 'f':
2259 fmt = optarg;
2260 break;
2261 case OPTION_OUTPUT:
2262 output = optarg;
2263 break;
2264 }
2265 }
2266 if (optind != argc - 1) {
2267 error_exit("Expecting one image file name");
2268 }
2269 filename = argv[optind];
2270
2271 if (output && !strcmp(output, "json")) {
2272 output_format = OFORMAT_JSON;
2273 } else if (output && !strcmp(output, "human")) {
2274 output_format = OFORMAT_HUMAN;
2275 } else if (output) {
2276 error_report("--output must be used with human or json as argument.");
2277 return 1;
2278 }
2279
2280 blk = img_open("image", filename, fmt, BDRV_O_FLAGS, true, false);
2281 if (!blk) {
2282 return 1;
2283 }
2284 bs = blk_bs(blk);
2285
2286 if (output_format == OFORMAT_HUMAN) {
2287 printf("%-16s%-16s%-16s%s\n", "Offset", "Length", "Mapped to", "File");
2288 }
2289
2290 length = blk_getlength(blk);
2291 while (curr.start + curr.length < length) {
2292 int64_t nsectors_left;
2293 int64_t sector_num;
2294 int n;
2295
2296 sector_num = (curr.start + curr.length) >> BDRV_SECTOR_BITS;
2297
2298 /* Probe up to 1 GiB at a time. */
2299 nsectors_left = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE) - sector_num;
2300 n = MIN(1 << (30 - BDRV_SECTOR_BITS), nsectors_left);
2301 ret = get_block_status(bs, sector_num, n, &next);
2302
2303 if (ret < 0) {
2304 error_report("Could not read file metadata: %s", strerror(-ret));
2305 goto out;
2306 }
2307
2308 if (curr.length != 0 && curr.flags == next.flags &&
2309 curr.depth == next.depth &&
2310 ((curr.flags & BDRV_BLOCK_OFFSET_VALID) == 0 ||
2311 curr.offset + curr.length == next.offset)) {
2312 curr.length += next.length;
2313 continue;
2314 }
2315
2316 if (curr.length > 0) {
2317 dump_map_entry(output_format, &curr, &next);
2318 }
2319 curr = next;
2320 }
2321
2322 dump_map_entry(output_format, &curr, NULL);
2323
2324 out:
2325 blk_unref(blk);
2326 return ret < 0;
2327 }
2328
2329 #define SNAPSHOT_LIST 1
2330 #define SNAPSHOT_CREATE 2
2331 #define SNAPSHOT_APPLY 3
2332 #define SNAPSHOT_DELETE 4
2333
2334 static int img_snapshot(int argc, char **argv)
2335 {
2336 BlockBackend *blk;
2337 BlockDriverState *bs;
2338 QEMUSnapshotInfo sn;
2339 char *filename, *snapshot_name = NULL;
2340 int c, ret = 0, bdrv_oflags;
2341 int action = 0;
2342 qemu_timeval tv;
2343 bool quiet = false;
2344 Error *err = NULL;
2345
2346 bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
2347 /* Parse commandline parameters */
2348 for(;;) {
2349 c = getopt(argc, argv, "la:c:d:hq");
2350 if (c == -1) {
2351 break;
2352 }
2353 switch(c) {
2354 case '?':
2355 case 'h':
2356 help();
2357 return 0;
2358 case 'l':
2359 if (action) {
2360 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2361 return 0;
2362 }
2363 action = SNAPSHOT_LIST;
2364 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
2365 break;
2366 case 'a':
2367 if (action) {
2368 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2369 return 0;
2370 }
2371 action = SNAPSHOT_APPLY;
2372 snapshot_name = optarg;
2373 break;
2374 case 'c':
2375 if (action) {
2376 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2377 return 0;
2378 }
2379 action = SNAPSHOT_CREATE;
2380 snapshot_name = optarg;
2381 break;
2382 case 'd':
2383 if (action) {
2384 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2385 return 0;
2386 }
2387 action = SNAPSHOT_DELETE;
2388 snapshot_name = optarg;
2389 break;
2390 case 'q':
2391 quiet = true;
2392 break;
2393 }
2394 }
2395
2396 if (optind != argc - 1) {
2397 error_exit("Expecting one image file name");
2398 }
2399 filename = argv[optind++];
2400
2401 /* Open the image */
2402 blk = img_open("image", filename, NULL, bdrv_oflags, true, quiet);
2403 if (!blk) {
2404 return 1;
2405 }
2406 bs = blk_bs(blk);
2407
2408 /* Perform the requested action */
2409 switch(action) {
2410 case SNAPSHOT_LIST:
2411 dump_snapshots(bs);
2412 break;
2413
2414 case SNAPSHOT_CREATE:
2415 memset(&sn, 0, sizeof(sn));
2416 pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
2417
2418 qemu_gettimeofday(&tv);
2419 sn.date_sec = tv.tv_sec;
2420 sn.date_nsec = tv.tv_usec * 1000;
2421
2422 ret = bdrv_snapshot_create(bs, &sn);
2423 if (ret) {
2424 error_report("Could not create snapshot '%s': %d (%s)",
2425 snapshot_name, ret, strerror(-ret));
2426 }
2427 break;
2428
2429 case SNAPSHOT_APPLY:
2430 ret = bdrv_snapshot_goto(bs, snapshot_name);
2431 if (ret) {
2432 error_report("Could not apply snapshot '%s': %d (%s)",
2433 snapshot_name, ret, strerror(-ret));
2434 }
2435 break;
2436
2437 case SNAPSHOT_DELETE:
2438 bdrv_snapshot_delete_by_id_or_name(bs, snapshot_name, &err);
2439 if (err) {
2440 error_report("Could not delete snapshot '%s': (%s)",
2441 snapshot_name, error_get_pretty(err));
2442 error_free(err);
2443 ret = 1;
2444 }
2445 break;
2446 }
2447
2448 /* Cleanup */
2449 blk_unref(blk);
2450 if (ret) {
2451 return 1;
2452 }
2453 return 0;
2454 }
2455
2456 static int img_rebase(int argc, char **argv)
2457 {
2458 BlockBackend *blk = NULL, *blk_old_backing = NULL, *blk_new_backing = NULL;
2459 BlockDriverState *bs = NULL;
2460 char *filename;
2461 const char *fmt, *cache, *src_cache, *out_basefmt, *out_baseimg;
2462 int c, flags, src_flags, ret;
2463 int unsafe = 0;
2464 int progress = 0;
2465 bool quiet = false;
2466 Error *local_err = NULL;
2467
2468 /* Parse commandline parameters */
2469 fmt = NULL;
2470 cache = BDRV_DEFAULT_CACHE;
2471 src_cache = BDRV_DEFAULT_CACHE;
2472 out_baseimg = NULL;
2473 out_basefmt = NULL;
2474 for(;;) {
2475 c = getopt(argc, argv, "hf:F:b:upt:T:q");
2476 if (c == -1) {
2477 break;
2478 }
2479 switch(c) {
2480 case '?':
2481 case 'h':
2482 help();
2483 return 0;
2484 case 'f':
2485 fmt = optarg;
2486 break;
2487 case 'F':
2488 out_basefmt = optarg;
2489 break;
2490 case 'b':
2491 out_baseimg = optarg;
2492 break;
2493 case 'u':
2494 unsafe = 1;
2495 break;
2496 case 'p':
2497 progress = 1;
2498 break;
2499 case 't':
2500 cache = optarg;
2501 break;
2502 case 'T':
2503 src_cache = optarg;
2504 break;
2505 case 'q':
2506 quiet = true;
2507 break;
2508 }
2509 }
2510
2511 if (quiet) {
2512 progress = 0;
2513 }
2514
2515 if (optind != argc - 1) {
2516 error_exit("Expecting one image file name");
2517 }
2518 if (!unsafe && !out_baseimg) {
2519 error_exit("Must specify backing file (-b) or use unsafe mode (-u)");
2520 }
2521 filename = argv[optind++];
2522
2523 qemu_progress_init(progress, 2.0);
2524 qemu_progress_print(0, 100);
2525
2526 flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
2527 ret = bdrv_parse_cache_flags(cache, &flags);
2528 if (ret < 0) {
2529 error_report("Invalid cache option: %s", cache);
2530 goto out;
2531 }
2532
2533 src_flags = BDRV_O_FLAGS;
2534 ret = bdrv_parse_cache_flags(src_cache, &src_flags);
2535 if (ret < 0) {
2536 error_report("Invalid source cache option: %s", src_cache);
2537 goto out;
2538 }
2539
2540 /*
2541 * Open the images.
2542 *
2543 * Ignore the old backing file for unsafe rebase in case we want to correct
2544 * the reference to a renamed or moved backing file.
2545 */
2546 blk = img_open("image", filename, fmt, flags, true, quiet);
2547 if (!blk) {
2548 ret = -1;
2549 goto out;
2550 }
2551 bs = blk_bs(blk);
2552
2553 if (out_basefmt != NULL) {
2554 if (bdrv_find_format(out_basefmt) == NULL) {
2555 error_report("Invalid format name: '%s'", out_basefmt);
2556 ret = -1;
2557 goto out;
2558 }
2559 }
2560
2561 /* For safe rebasing we need to compare old and new backing file */
2562 if (!unsafe) {
2563 char backing_name[PATH_MAX];
2564 QDict *options = NULL;
2565
2566 if (bs->backing_format[0] != '\0') {
2567 options = qdict_new();
2568 qdict_put(options, "driver", qstring_from_str(bs->backing_format));
2569 }
2570
2571 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
2572 blk_old_backing = blk_new_open("old_backing", backing_name, NULL,
2573 options, src_flags, &local_err);
2574 if (!blk_old_backing) {
2575 error_report("Could not open old backing file '%s': %s",
2576 backing_name, error_get_pretty(local_err));
2577 error_free(local_err);
2578 goto out;
2579 }
2580
2581 if (out_baseimg[0]) {
2582 if (out_basefmt) {
2583 options = qdict_new();
2584 qdict_put(options, "driver", qstring_from_str(out_basefmt));
2585 } else {
2586 options = NULL;
2587 }
2588
2589 blk_new_backing = blk_new_open("new_backing", out_baseimg, NULL,
2590 options, src_flags, &local_err);
2591 if (!blk_new_backing) {
2592 error_report("Could not open new backing file '%s': %s",
2593 out_baseimg, error_get_pretty(local_err));
2594 error_free(local_err);
2595 goto out;
2596 }
2597 }
2598 }
2599
2600 /*
2601 * Check each unallocated cluster in the COW file. If it is unallocated,
2602 * accesses go to the backing file. We must therefore compare this cluster
2603 * in the old and new backing file, and if they differ we need to copy it
2604 * from the old backing file into the COW file.
2605 *
2606 * If qemu-img crashes during this step, no harm is done. The content of
2607 * the image is the same as the original one at any time.
2608 */
2609 if (!unsafe) {
2610 int64_t num_sectors;
2611 int64_t old_backing_num_sectors;
2612 int64_t new_backing_num_sectors = 0;
2613 uint64_t sector;
2614 int n;
2615 uint8_t * buf_old;
2616 uint8_t * buf_new;
2617 float local_progress = 0;
2618
2619 buf_old = blk_blockalign(blk, IO_BUF_SIZE);
2620 buf_new = blk_blockalign(blk, IO_BUF_SIZE);
2621
2622 num_sectors = blk_nb_sectors(blk);
2623 if (num_sectors < 0) {
2624 error_report("Could not get size of '%s': %s",
2625 filename, strerror(-num_sectors));
2626 ret = -1;
2627 goto out;
2628 }
2629 old_backing_num_sectors = blk_nb_sectors(blk_old_backing);
2630 if (old_backing_num_sectors < 0) {
2631 char backing_name[PATH_MAX];
2632
2633 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
2634 error_report("Could not get size of '%s': %s",
2635 backing_name, strerror(-old_backing_num_sectors));
2636 ret = -1;
2637 goto out;
2638 }
2639 if (blk_new_backing) {
2640 new_backing_num_sectors = blk_nb_sectors(blk_new_backing);
2641 if (new_backing_num_sectors < 0) {
2642 error_report("Could not get size of '%s': %s",
2643 out_baseimg, strerror(-new_backing_num_sectors));
2644 ret = -1;
2645 goto out;
2646 }
2647 }
2648
2649 if (num_sectors != 0) {
2650 local_progress = (float)100 /
2651 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
2652 }
2653
2654 for (sector = 0; sector < num_sectors; sector += n) {
2655
2656 /* How many sectors can we handle with the next read? */
2657 if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
2658 n = (IO_BUF_SIZE / 512);
2659 } else {
2660 n = num_sectors - sector;
2661 }
2662
2663 /* If the cluster is allocated, we don't need to take action */
2664 ret = bdrv_is_allocated(bs, sector, n, &n);
2665 if (ret < 0) {
2666 error_report("error while reading image metadata: %s",
2667 strerror(-ret));
2668 goto out;
2669 }
2670 if (ret) {
2671 continue;
2672 }
2673
2674 /*
2675 * Read old and new backing file and take into consideration that
2676 * backing files may be smaller than the COW image.
2677 */
2678 if (sector >= old_backing_num_sectors) {
2679 memset(buf_old, 0, n * BDRV_SECTOR_SIZE);
2680 } else {
2681 if (sector + n > old_backing_num_sectors) {
2682 n = old_backing_num_sectors - sector;
2683 }
2684
2685 ret = blk_read(blk_old_backing, sector, buf_old, n);
2686 if (ret < 0) {
2687 error_report("error while reading from old backing file");
2688 goto out;
2689 }
2690 }
2691
2692 if (sector >= new_backing_num_sectors || !blk_new_backing) {
2693 memset(buf_new, 0, n * BDRV_SECTOR_SIZE);
2694 } else {
2695 if (sector + n > new_backing_num_sectors) {
2696 n = new_backing_num_sectors - sector;
2697 }
2698
2699 ret = blk_read(blk_new_backing, sector, buf_new, n);
2700 if (ret < 0) {
2701 error_report("error while reading from new backing file");
2702 goto out;
2703 }
2704 }
2705
2706 /* If they differ, we need to write to the COW file */
2707 uint64_t written = 0;
2708
2709 while (written < n) {
2710 int pnum;
2711
2712 if (compare_sectors(buf_old + written * 512,
2713 buf_new + written * 512, n - written, &pnum))
2714 {
2715 ret = blk_write(blk, sector + written,
2716 buf_old + written * 512, pnum);
2717 if (ret < 0) {
2718 error_report("Error while writing to COW image: %s",
2719 strerror(-ret));
2720 goto out;
2721 }
2722 }
2723
2724 written += pnum;
2725 }
2726 qemu_progress_print(local_progress, 100);
2727 }
2728
2729 qemu_vfree(buf_old);
2730 qemu_vfree(buf_new);
2731 }
2732
2733 /*
2734 * Change the backing file. All clusters that are different from the old
2735 * backing file are overwritten in the COW file now, so the visible content
2736 * doesn't change when we switch the backing file.
2737 */
2738 if (out_baseimg && *out_baseimg) {
2739 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
2740 } else {
2741 ret = bdrv_change_backing_file(bs, NULL, NULL);
2742 }
2743
2744 if (ret == -ENOSPC) {
2745 error_report("Could not change the backing file to '%s': No "
2746 "space left in the file header", out_baseimg);
2747 } else if (ret < 0) {
2748 error_report("Could not change the backing file to '%s': %s",
2749 out_baseimg, strerror(-ret));
2750 }
2751
2752 qemu_progress_print(100, 0);
2753 /*
2754 * TODO At this point it is possible to check if any clusters that are
2755 * allocated in the COW file are the same in the backing file. If so, they
2756 * could be dropped from the COW file. Don't do this before switching the
2757 * backing file, in case of a crash this would lead to corruption.
2758 */
2759 out:
2760 qemu_progress_end();
2761 /* Cleanup */
2762 if (!unsafe) {
2763 blk_unref(blk_old_backing);
2764 blk_unref(blk_new_backing);
2765 }
2766
2767 blk_unref(blk);
2768 if (ret) {
2769 return 1;
2770 }
2771 return 0;
2772 }
2773
2774 static int img_resize(int argc, char **argv)
2775 {
2776 Error *err = NULL;
2777 int c, ret, relative;
2778 const char *filename, *fmt, *size;
2779 int64_t n, total_size;
2780 bool quiet = false;
2781 BlockBackend *blk = NULL;
2782 QemuOpts *param;
2783 static QemuOptsList resize_options = {
2784 .name = "resize_options",
2785 .head = QTAILQ_HEAD_INITIALIZER(resize_options.head),
2786 .desc = {
2787 {
2788 .name = BLOCK_OPT_SIZE,
2789 .type = QEMU_OPT_SIZE,
2790 .help = "Virtual disk size"
2791 }, {
2792 /* end of list */
2793 }
2794 },
2795 };
2796
2797 /* Remove size from argv manually so that negative numbers are not treated
2798 * as options by getopt. */
2799 if (argc < 3) {
2800 error_exit("Not enough arguments");
2801 return 1;
2802 }
2803
2804 size = argv[--argc];
2805
2806 /* Parse getopt arguments */
2807 fmt = NULL;
2808 for(;;) {
2809 c = getopt(argc, argv, "f:hq");
2810 if (c == -1) {
2811 break;
2812 }
2813 switch(c) {
2814 case '?':
2815 case 'h':
2816 help();
2817 break;
2818 case 'f':
2819 fmt = optarg;
2820 break;
2821 case 'q':
2822 quiet = true;
2823 break;
2824 }
2825 }
2826 if (optind != argc - 1) {
2827 error_exit("Expecting one image file name");
2828 }
2829 filename = argv[optind++];
2830
2831 /* Choose grow, shrink, or absolute resize mode */
2832 switch (size[0]) {
2833 case '+':
2834 relative = 1;
2835 size++;
2836 break;
2837 case '-':
2838 relative = -1;
2839 size++;
2840 break;
2841 default:
2842 relative = 0;
2843 break;
2844 }
2845
2846 /* Parse size */
2847 param = qemu_opts_create(&resize_options, NULL, 0, &error_abort);
2848 qemu_opt_set(param, BLOCK_OPT_SIZE, size, &err);
2849 if (err) {
2850 error_report_err(err);
2851 ret = -1;
2852 qemu_opts_del(param);
2853 goto out;
2854 }
2855 n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
2856 qemu_opts_del(param);
2857
2858 blk = img_open("image", filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR,
2859 true, quiet);
2860 if (!blk) {
2861 ret = -1;
2862 goto out;
2863 }
2864
2865 if (relative) {
2866 total_size = blk_getlength(blk) + n * relative;
2867 } else {
2868 total_size = n;
2869 }
2870 if (total_size <= 0) {
2871 error_report("New image size must be positive");
2872 ret = -1;
2873 goto out;
2874 }
2875
2876 ret = blk_truncate(blk, total_size);
2877 switch (ret) {
2878 case 0:
2879 qprintf(quiet, "Image resized.\n");
2880 break;
2881 case -ENOTSUP:
2882 error_report("This image does not support resize");
2883 break;
2884 case -EACCES:
2885 error_report("Image is read-only");
2886 break;
2887 default:
2888 error_report("Error resizing image (%d)", -ret);
2889 break;
2890 }
2891 out:
2892 blk_unref(blk);
2893 if (ret) {
2894 return 1;
2895 }
2896 return 0;
2897 }
2898
2899 static void amend_status_cb(BlockDriverState *bs,
2900 int64_t offset, int64_t total_work_size)
2901 {
2902 qemu_progress_print(100.f * offset / total_work_size, 0);
2903 }
2904
2905 static int img_amend(int argc, char **argv)
2906 {
2907 Error *err = NULL;
2908 int c, ret = 0;
2909 char *options = NULL;
2910 QemuOptsList *create_opts = NULL;
2911 QemuOpts *opts = NULL;
2912 const char *fmt = NULL, *filename, *cache;
2913 int flags;
2914 bool quiet = false, progress = false;
2915 BlockBackend *blk = NULL;
2916 BlockDriverState *bs = NULL;
2917
2918 cache = BDRV_DEFAULT_CACHE;
2919 for (;;) {
2920 c = getopt(argc, argv, "ho:f:t:pq");
2921 if (c == -1) {
2922 break;
2923 }
2924
2925 switch (c) {
2926 case 'h':
2927 case '?':
2928 help();
2929 break;
2930 case 'o':
2931 if (!is_valid_option_list(optarg)) {
2932 error_report("Invalid option list: %s", optarg);
2933 ret = -1;
2934 goto out;
2935 }
2936 if (!options) {
2937 options = g_strdup(optarg);
2938 } else {
2939 char *old_options = options;
2940 options = g_strdup_printf("%s,%s", options, optarg);
2941 g_free(old_options);
2942 }
2943 break;
2944 case 'f':
2945 fmt = optarg;
2946 break;
2947 case 't':
2948 cache = optarg;
2949 break;
2950 case 'p':
2951 progress = true;
2952 break;
2953 case 'q':
2954 quiet = true;
2955 break;
2956 }
2957 }
2958
2959 if (!options) {
2960 error_exit("Must specify options (-o)");
2961 }
2962
2963 if (quiet) {
2964 progress = false;
2965 }
2966 qemu_progress_init(progress, 1.0);
2967
2968 filename = (optind == argc - 1) ? argv[argc - 1] : NULL;
2969 if (fmt && has_help_option(options)) {
2970 /* If a format is explicitly specified (and possibly no filename is
2971 * given), print option help here */
2972 ret = print_block_option_help(filename, fmt);
2973 goto out;
2974 }
2975
2976 if (optind != argc - 1) {
2977 error_report("Expecting one image file name");
2978 ret = -1;
2979 goto out;
2980 }
2981
2982 flags = BDRV_O_FLAGS | BDRV_O_RDWR;
2983 ret = bdrv_parse_cache_flags(cache, &flags);
2984 if (ret < 0) {
2985 error_report("Invalid cache option: %s", cache);
2986 goto out;
2987 }
2988
2989 blk = img_open("image", filename, fmt, flags, true, quiet);
2990 if (!blk) {
2991 ret = -1;
2992 goto out;
2993 }
2994 bs = blk_bs(blk);
2995
2996 fmt = bs->drv->format_name;
2997
2998 if (has_help_option(options)) {
2999 /* If the format was auto-detected, print option help here */
3000 ret = print_block_option_help(filename, fmt);
3001 goto out;
3002 }
3003
3004 if (!bs->drv->create_opts) {
3005 error_report("Format driver '%s' does not support any options to amend",
3006 fmt);
3007 ret = -1;
3008 goto out;
3009 }
3010
3011 create_opts = qemu_opts_append(create_opts, bs->drv->create_opts);
3012 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
3013 if (options) {
3014 qemu_opts_do_parse(opts, options, NULL, &err);
3015 if (err) {
3016 error_report_err(err);
3017 ret = -1;
3018 goto out;
3019 }
3020 }
3021
3022 /* In case the driver does not call amend_status_cb() */
3023 qemu_progress_print(0.f, 0);
3024 ret = bdrv_amend_options(bs, opts, &amend_status_cb);
3025 qemu_progress_print(100.f, 0);
3026 if (ret < 0) {
3027 error_report("Error while amending options: %s", strerror(-ret));
3028 goto out;
3029 }
3030
3031 out:
3032 qemu_progress_end();
3033
3034 blk_unref(blk);
3035 qemu_opts_del(opts);
3036 qemu_opts_free(create_opts);
3037 g_free(options);
3038
3039 if (ret) {
3040 return 1;
3041 }
3042 return 0;
3043 }
3044
3045 static const img_cmd_t img_cmds[] = {
3046 #define DEF(option, callback, arg_string) \
3047 { option, callback },
3048 #include "qemu-img-cmds.h"
3049 #undef DEF
3050 #undef GEN_DOCS
3051 { NULL, NULL, },
3052 };
3053
3054 int main(int argc, char **argv)
3055 {
3056 const img_cmd_t *cmd;
3057 const char *cmdname;
3058 Error *local_error = NULL;
3059 int c;
3060 static const struct option long_options[] = {
3061 {"help", no_argument, 0, 'h'},
3062 {"version", no_argument, 0, 'v'},
3063 {0, 0, 0, 0}
3064 };
3065
3066 #ifdef CONFIG_POSIX
3067 signal(SIGPIPE, SIG_IGN);
3068 #endif
3069
3070 error_set_progname(argv[0]);
3071 qemu_init_exec_dir(argv[0]);
3072
3073 if (qemu_init_main_loop(&local_error)) {
3074 error_report_err(local_error);
3075 exit(EXIT_FAILURE);
3076 }
3077
3078 bdrv_init();
3079 if (argc < 2) {
3080 error_exit("Not enough arguments");
3081 }
3082 cmdname = argv[1];
3083
3084 /* find the command */
3085 for (cmd = img_cmds; cmd->name != NULL; cmd++) {
3086 if (!strcmp(cmdname, cmd->name)) {
3087 return cmd->handler(argc - 1, argv + 1);
3088 }
3089 }
3090
3091 c = getopt_long(argc, argv, "h", long_options, NULL);
3092
3093 if (c == 'h') {
3094 help();
3095 }
3096 if (c == 'v') {
3097 printf(QEMU_IMG_VERSION);
3098 return 0;
3099 }
3100
3101 /* not found */
3102 error_exit("Command not found: %s", cmdname);
3103 }