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