?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
scripts/qmp: Use Python 2.6 "except E as ..." syntax
[qemu/armbru.git] / qemu-img.c
blobf121980707dfe28bd73e3512b6604b704ac02827
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),
380 &check, NULL, &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),
1946 &list, NULL, &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),
1963 &info, NULL, &local_err);
1964 obj = qmp_output_get_qobject(ov);
1965 str = qobject_to_json_pretty(obj);
1966 assert(str != NULL);
1967 printf("%s\n", qstring_get_str(str));
1968 qobject_decref(obj);
1969 qmp_output_visitor_cleanup(ov);
1970 QDECREF(str);
1971 }
1972
1973 static void dump_human_image_info_list(ImageInfoList *list)
1974 {
1975 ImageInfoList *elem;
1976 bool delim = false;
1977
1978 for (elem = list; elem; elem = elem->next) {
1979 if (delim) {
1980 printf("\n");
1981 }
1982 delim = true;
1983
1984 bdrv_image_info_dump(fprintf, stdout, elem->value);
1985 }
1986 }
1987
1988 static gboolean str_equal_func(gconstpointer a, gconstpointer b)
1989 {
1990 return strcmp(a, b) == 0;
1991 }
1992
1993 /**
1994 * Open an image file chain and return an ImageInfoList
1995 *
1996 * @filename: topmost image filename
1997 * @fmt: topmost image format (may be NULL to autodetect)
1998 * @chain: true - enumerate entire backing file chain
1999 * false - only topmost image file
2000 *
2001 * Returns a list of ImageInfo objects or NULL if there was an error opening an
2002 * image file. If there was an error a message will have been printed to
2003 * stderr.
2004 */
2005 static ImageInfoList *collect_image_info_list(const char *filename,
2006 const char *fmt,
2007 bool chain)
2008 {
2009 ImageInfoList *head = NULL;
2010 ImageInfoList **last = &head;
2011 GHashTable *filenames;
2012 Error *err = NULL;
2013
2014 filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL);
2015
2016 while (filename) {
2017 BlockBackend *blk;
2018 BlockDriverState *bs;
2019 ImageInfo *info;
2020 ImageInfoList *elem;
2021
2022 if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) {
2023 error_report("Backing file '%s' creates an infinite loop.",
2024 filename);
2025 goto err;
2026 }
2027 g_hash_table_insert(filenames, (gpointer)filename, NULL);
2028
2029 blk = img_open("image", filename, fmt,
2030 BDRV_O_FLAGS | BDRV_O_NO_BACKING, false, false);
2031 if (!blk) {
2032 goto err;
2033 }
2034 bs = blk_bs(blk);
2035
2036 bdrv_query_image_info(bs, &info, &err);
2037 if (err) {
2038 error_report_err(err);
2039 blk_unref(blk);
2040 goto err;
2041 }
2042
2043 elem = g_new0(ImageInfoList, 1);
2044 elem->value = info;
2045 *last = elem;
2046 last = &elem->next;
2047
2048 blk_unref(blk);
2049
2050 filename = fmt = NULL;
2051 if (chain) {
2052 if (info->has_full_backing_filename) {
2053 filename = info->full_backing_filename;
2054 } else if (info->has_backing_filename) {
2055 error_report("Could not determine absolute backing filename,"
2056 " but backing filename '%s' present",
2057 info->backing_filename);
2058 goto err;
2059 }
2060 if (info->has_backing_filename_format) {
2061 fmt = info->backing_filename_format;
2062 }
2063 }
2064 }
2065 g_hash_table_destroy(filenames);
2066 return head;
2067
2068 err:
2069 qapi_free_ImageInfoList(head);
2070 g_hash_table_destroy(filenames);
2071 return NULL;
2072 }
2073
2074 static int img_info(int argc, char **argv)
2075 {
2076 int c;
2077 OutputFormat output_format = OFORMAT_HUMAN;
2078 bool chain = false;
2079 const char *filename, *fmt, *output;
2080 ImageInfoList *list;
2081
2082 fmt = NULL;
2083 output = NULL;
2084 for(;;) {
2085 int option_index = 0;
2086 static const struct option long_options[] = {
2087 {"help", no_argument, 0, 'h'},
2088 {"format", required_argument, 0, 'f'},
2089 {"output", required_argument, 0, OPTION_OUTPUT},
2090 {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN},
2091 {0, 0, 0, 0}
2092 };
2093 c = getopt_long(argc, argv, "f:h",
2094 long_options, &option_index);
2095 if (c == -1) {
2096 break;
2097 }
2098 switch(c) {
2099 case '?':
2100 case 'h':
2101 help();
2102 break;
2103 case 'f':
2104 fmt = optarg;
2105 break;
2106 case OPTION_OUTPUT:
2107 output = optarg;
2108 break;
2109 case OPTION_BACKING_CHAIN:
2110 chain = true;
2111 break;
2112 }
2113 }
2114 if (optind != argc - 1) {
2115 error_exit("Expecting one image file name");
2116 }
2117 filename = argv[optind++];
2118
2119 if (output && !strcmp(output, "json")) {
2120 output_format = OFORMAT_JSON;
2121 } else if (output && !strcmp(output, "human")) {
2122 output_format = OFORMAT_HUMAN;
2123 } else if (output) {
2124 error_report("--output must be used with human or json as argument.");
2125 return 1;
2126 }
2127
2128 list = collect_image_info_list(filename, fmt, chain);
2129 if (!list) {
2130 return 1;
2131 }
2132
2133 switch (output_format) {
2134 case OFORMAT_HUMAN:
2135 dump_human_image_info_list(list);
2136 break;
2137 case OFORMAT_JSON:
2138 if (chain) {
2139 dump_json_image_info_list(list);
2140 } else {
2141 dump_json_image_info(list->value);
2142 }
2143 break;
2144 }
2145
2146 qapi_free_ImageInfoList(list);
2147 return 0;
2148 }
2149
2150 static void dump_map_entry(OutputFormat output_format, MapEntry *e,
2151 MapEntry *next)
2152 {
2153 switch (output_format) {
2154 case OFORMAT_HUMAN:
2155 if (e->data && !e->has_offset) {
2156 error_report("File contains external, encrypted or compressed clusters.");
2157 exit(1);
2158 }
2159 if (e->data && !e->zero) {
2160 printf("%#-16"PRIx64"%#-16"PRIx64"%#-16"PRIx64"%s\n",
2161 e->start, e->length,
2162 e->has_offset ? e->offset : 0,
2163 e->has_filename ? e->filename : "");
2164 }
2165 /* This format ignores the distinction between 0, ZERO and ZERO|DATA.
2166 * Modify the flags here to allow more coalescing.
2167 */
2168 if (next && (!next->data || next->zero)) {
2169 next->data = false;
2170 next->zero = true;
2171 }
2172 break;
2173 case OFORMAT_JSON:
2174 printf("%s{ \"start\": %"PRId64", \"length\": %"PRId64","
2175 " \"depth\": %"PRId64", \"zero\": %s, \"data\": %s",
2176 (e->start == 0 ? "[" : ",\n"),
2177 e->start, e->length, e->depth,
2178 e->zero ? "true" : "false",
2179 e->data ? "true" : "false");
2180 if (e->has_offset) {
2181 printf(", \"offset\": %"PRId64"", e->offset);
2182 }
2183 putchar('}');
2184
2185 if (!next) {
2186 printf("]\n");
2187 }
2188 break;
2189 }
2190 }
2191
2192 static int get_block_status(BlockDriverState *bs, int64_t sector_num,
2193 int nb_sectors, MapEntry *e)
2194 {
2195 int64_t ret;
2196 int depth;
2197 BlockDriverState *file;
2198
2199 /* As an optimization, we could cache the current range of unallocated
2200 * clusters in each file of the chain, and avoid querying the same
2201 * range repeatedly.
2202 */
2203
2204 depth = 0;
2205 for (;;) {
2206 ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &nb_sectors,
2207 &file);
2208 if (ret < 0) {
2209 return ret;
2210 }
2211 assert(nb_sectors);
2212 if (ret & (BDRV_BLOCK_ZERO|BDRV_BLOCK_DATA)) {
2213 break;
2214 }
2215 bs = backing_bs(bs);
2216 if (bs == NULL) {
2217 ret = 0;
2218 break;
2219 }
2220
2221 depth++;
2222 }
2223
2224 e->start = sector_num * BDRV_SECTOR_SIZE;
2225 e->length = nb_sectors * BDRV_SECTOR_SIZE;
2226 e->data = !!(ret & BDRV_BLOCK_DATA);
2227 e->zero = !!(ret & BDRV_BLOCK_ZERO);
2228 e->offset = ret & BDRV_BLOCK_OFFSET_MASK;
2229 e->has_offset = !!(ret & BDRV_BLOCK_OFFSET_VALID);
2230 e->depth = depth;
2231 if (file && e->has_offset) {
2232 e->has_filename = true;
2233 e->filename = file->filename;
2234 }
2235 return 0;
2236 }
2237
2238 static inline bool entry_mergeable(const MapEntry *curr, const MapEntry *next)
2239 {
2240 if (curr->length == 0) {
2241 return false;
2242 }
2243 if (curr->zero != next->zero ||
2244 curr->data != next->data ||
2245 curr->depth != next->depth ||
2246 curr->has_filename != next->has_filename ||
2247 curr->has_offset != next->has_offset) {
2248 return false;
2249 }
2250 if (curr->has_filename && strcmp(curr->filename, next->filename)) {
2251 return false;
2252 }
2253 if (curr->has_offset && curr->offset + curr->length != next->offset) {
2254 return false;
2255 }
2256 return true;
2257 }
2258
2259 static int img_map(int argc, char **argv)
2260 {
2261 int c;
2262 OutputFormat output_format = OFORMAT_HUMAN;
2263 BlockBackend *blk;
2264 BlockDriverState *bs;
2265 const char *filename, *fmt, *output;
2266 int64_t length;
2267 MapEntry curr = { .length = 0 }, next;
2268 int ret = 0;
2269
2270 fmt = NULL;
2271 output = NULL;
2272 for (;;) {
2273 int option_index = 0;
2274 static const struct option long_options[] = {
2275 {"help", no_argument, 0, 'h'},
2276 {"format", required_argument, 0, 'f'},
2277 {"output", required_argument, 0, OPTION_OUTPUT},
2278 {0, 0, 0, 0}
2279 };
2280 c = getopt_long(argc, argv, "f:h",
2281 long_options, &option_index);
2282 if (c == -1) {
2283 break;
2284 }
2285 switch (c) {
2286 case '?':
2287 case 'h':
2288 help();
2289 break;
2290 case 'f':
2291 fmt = optarg;
2292 break;
2293 case OPTION_OUTPUT:
2294 output = optarg;
2295 break;
2296 }
2297 }
2298 if (optind != argc - 1) {
2299 error_exit("Expecting one image file name");
2300 }
2301 filename = argv[optind];
2302
2303 if (output && !strcmp(output, "json")) {
2304 output_format = OFORMAT_JSON;
2305 } else if (output && !strcmp(output, "human")) {
2306 output_format = OFORMAT_HUMAN;
2307 } else if (output) {
2308 error_report("--output must be used with human or json as argument.");
2309 return 1;
2310 }
2311
2312 blk = img_open("image", filename, fmt, BDRV_O_FLAGS, true, false);
2313 if (!blk) {
2314 return 1;
2315 }
2316 bs = blk_bs(blk);
2317
2318 if (output_format == OFORMAT_HUMAN) {
2319 printf("%-16s%-16s%-16s%s\n", "Offset", "Length", "Mapped to", "File");
2320 }
2321
2322 length = blk_getlength(blk);
2323 while (curr.start + curr.length < length) {
2324 int64_t nsectors_left;
2325 int64_t sector_num;
2326 int n;
2327
2328 sector_num = (curr.start + curr.length) >> BDRV_SECTOR_BITS;
2329
2330 /* Probe up to 1 GiB at a time. */
2331 nsectors_left = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE) - sector_num;
2332 n = MIN(1 << (30 - BDRV_SECTOR_BITS), nsectors_left);
2333 ret = get_block_status(bs, sector_num, n, &next);
2334
2335 if (ret < 0) {
2336 error_report("Could not read file metadata: %s", strerror(-ret));
2337 goto out;
2338 }
2339
2340 if (entry_mergeable(&curr, &next)) {
2341 curr.length += next.length;
2342 continue;
2343 }
2344
2345 if (curr.length > 0) {
2346 dump_map_entry(output_format, &curr, &next);
2347 }
2348 curr = next;
2349 }
2350
2351 dump_map_entry(output_format, &curr, NULL);
2352
2353 out:
2354 blk_unref(blk);
2355 return ret < 0;
2356 }
2357
2358 #define SNAPSHOT_LIST 1
2359 #define SNAPSHOT_CREATE 2
2360 #define SNAPSHOT_APPLY 3
2361 #define SNAPSHOT_DELETE 4
2362
2363 static int img_snapshot(int argc, char **argv)
2364 {
2365 BlockBackend *blk;
2366 BlockDriverState *bs;
2367 QEMUSnapshotInfo sn;
2368 char *filename, *snapshot_name = NULL;
2369 int c, ret = 0, bdrv_oflags;
2370 int action = 0;
2371 qemu_timeval tv;
2372 bool quiet = false;
2373 Error *err = NULL;
2374
2375 bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
2376 /* Parse commandline parameters */
2377 for(;;) {
2378 c = getopt(argc, argv, "la:c:d:hq");
2379 if (c == -1) {
2380 break;
2381 }
2382 switch(c) {
2383 case '?':
2384 case 'h':
2385 help();
2386 return 0;
2387 case 'l':
2388 if (action) {
2389 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2390 return 0;
2391 }
2392 action = SNAPSHOT_LIST;
2393 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
2394 break;
2395 case 'a':
2396 if (action) {
2397 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2398 return 0;
2399 }
2400 action = SNAPSHOT_APPLY;
2401 snapshot_name = optarg;
2402 break;
2403 case 'c':
2404 if (action) {
2405 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2406 return 0;
2407 }
2408 action = SNAPSHOT_CREATE;
2409 snapshot_name = optarg;
2410 break;
2411 case 'd':
2412 if (action) {
2413 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2414 return 0;
2415 }
2416 action = SNAPSHOT_DELETE;
2417 snapshot_name = optarg;
2418 break;
2419 case 'q':
2420 quiet = true;
2421 break;
2422 }
2423 }
2424
2425 if (optind != argc - 1) {
2426 error_exit("Expecting one image file name");
2427 }
2428 filename = argv[optind++];
2429
2430 /* Open the image */
2431 blk = img_open("image", filename, NULL, bdrv_oflags, true, quiet);
2432 if (!blk) {
2433 return 1;
2434 }
2435 bs = blk_bs(blk);
2436
2437 /* Perform the requested action */
2438 switch(action) {
2439 case SNAPSHOT_LIST:
2440 dump_snapshots(bs);
2441 break;
2442
2443 case SNAPSHOT_CREATE:
2444 memset(&sn, 0, sizeof(sn));
2445 pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
2446
2447 qemu_gettimeofday(&tv);
2448 sn.date_sec = tv.tv_sec;
2449 sn.date_nsec = tv.tv_usec * 1000;
2450
2451 ret = bdrv_snapshot_create(bs, &sn);
2452 if (ret) {
2453 error_report("Could not create snapshot '%s': %d (%s)",
2454 snapshot_name, ret, strerror(-ret));
2455 }
2456 break;
2457
2458 case SNAPSHOT_APPLY:
2459 ret = bdrv_snapshot_goto(bs, snapshot_name);
2460 if (ret) {
2461 error_report("Could not apply snapshot '%s': %d (%s)",
2462 snapshot_name, ret, strerror(-ret));
2463 }
2464 break;
2465
2466 case SNAPSHOT_DELETE:
2467 bdrv_snapshot_delete_by_id_or_name(bs, snapshot_name, &err);
2468 if (err) {
2469 error_reportf_err(err, "Could not delete snapshot '%s': ",
2470 snapshot_name);
2471 ret = 1;
2472 }
2473 break;
2474 }
2475
2476 /* Cleanup */
2477 blk_unref(blk);
2478 if (ret) {
2479 return 1;
2480 }
2481 return 0;
2482 }
2483
2484 static int img_rebase(int argc, char **argv)
2485 {
2486 BlockBackend *blk = NULL, *blk_old_backing = NULL, *blk_new_backing = NULL;
2487 BlockDriverState *bs = NULL;
2488 char *filename;
2489 const char *fmt, *cache, *src_cache, *out_basefmt, *out_baseimg;
2490 int c, flags, src_flags, ret;
2491 int unsafe = 0;
2492 int progress = 0;
2493 bool quiet = false;
2494 Error *local_err = NULL;
2495
2496 /* Parse commandline parameters */
2497 fmt = NULL;
2498 cache = BDRV_DEFAULT_CACHE;
2499 src_cache = BDRV_DEFAULT_CACHE;
2500 out_baseimg = NULL;
2501 out_basefmt = NULL;
2502 for(;;) {
2503 c = getopt(argc, argv, "hf:F:b:upt:T:q");
2504 if (c == -1) {
2505 break;
2506 }
2507 switch(c) {
2508 case '?':
2509 case 'h':
2510 help();
2511 return 0;
2512 case 'f':
2513 fmt = optarg;
2514 break;
2515 case 'F':
2516 out_basefmt = optarg;
2517 break;
2518 case 'b':
2519 out_baseimg = optarg;
2520 break;
2521 case 'u':
2522 unsafe = 1;
2523 break;
2524 case 'p':
2525 progress = 1;
2526 break;
2527 case 't':
2528 cache = optarg;
2529 break;
2530 case 'T':
2531 src_cache = optarg;
2532 break;
2533 case 'q':
2534 quiet = true;
2535 break;
2536 }
2537 }
2538
2539 if (quiet) {
2540 progress = 0;
2541 }
2542
2543 if (optind != argc - 1) {
2544 error_exit("Expecting one image file name");
2545 }
2546 if (!unsafe && !out_baseimg) {
2547 error_exit("Must specify backing file (-b) or use unsafe mode (-u)");
2548 }
2549 filename = argv[optind++];
2550
2551 qemu_progress_init(progress, 2.0);
2552 qemu_progress_print(0, 100);
2553
2554 flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
2555 ret = bdrv_parse_cache_flags(cache, &flags);
2556 if (ret < 0) {
2557 error_report("Invalid cache option: %s", cache);
2558 goto out;
2559 }
2560
2561 src_flags = BDRV_O_FLAGS;
2562 ret = bdrv_parse_cache_flags(src_cache, &src_flags);
2563 if (ret < 0) {
2564 error_report("Invalid source cache option: %s", src_cache);
2565 goto out;
2566 }
2567
2568 /*
2569 * Open the images.
2570 *
2571 * Ignore the old backing file for unsafe rebase in case we want to correct
2572 * the reference to a renamed or moved backing file.
2573 */
2574 blk = img_open("image", filename, fmt, flags, true, quiet);
2575 if (!blk) {
2576 ret = -1;
2577 goto out;
2578 }
2579 bs = blk_bs(blk);
2580
2581 if (out_basefmt != NULL) {
2582 if (bdrv_find_format(out_basefmt) == NULL) {
2583 error_report("Invalid format name: '%s'", out_basefmt);
2584 ret = -1;
2585 goto out;
2586 }
2587 }
2588
2589 /* For safe rebasing we need to compare old and new backing file */
2590 if (!unsafe) {
2591 char backing_name[PATH_MAX];
2592 QDict *options = NULL;
2593
2594 if (bs->backing_format[0] != '\0') {
2595 options = qdict_new();
2596 qdict_put(options, "driver", qstring_from_str(bs->backing_format));
2597 }
2598
2599 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
2600 blk_old_backing = blk_new_open("old_backing", backing_name, NULL,
2601 options, src_flags, &local_err);
2602 if (!blk_old_backing) {
2603 error_reportf_err(local_err,
2604 "Could not open old backing file '%s': ",
2605 backing_name);
2606 goto out;
2607 }
2608
2609 if (out_baseimg[0]) {
2610 if (out_basefmt) {
2611 options = qdict_new();
2612 qdict_put(options, "driver", qstring_from_str(out_basefmt));
2613 } else {
2614 options = NULL;
2615 }
2616
2617 blk_new_backing = blk_new_open("new_backing", out_baseimg, NULL,
2618 options, src_flags, &local_err);
2619 if (!blk_new_backing) {
2620 error_reportf_err(local_err,
2621 "Could not open new backing file '%s': ",
2622 out_baseimg);
2623 goto out;
2624 }
2625 }
2626 }
2627
2628 /*
2629 * Check each unallocated cluster in the COW file. If it is unallocated,
2630 * accesses go to the backing file. We must therefore compare this cluster
2631 * in the old and new backing file, and if they differ we need to copy it
2632 * from the old backing file into the COW file.
2633 *
2634 * If qemu-img crashes during this step, no harm is done. The content of
2635 * the image is the same as the original one at any time.
2636 */
2637 if (!unsafe) {
2638 int64_t num_sectors;
2639 int64_t old_backing_num_sectors;
2640 int64_t new_backing_num_sectors = 0;
2641 uint64_t sector;
2642 int n;
2643 uint8_t * buf_old;
2644 uint8_t * buf_new;
2645 float local_progress = 0;
2646
2647 buf_old = blk_blockalign(blk, IO_BUF_SIZE);
2648 buf_new = blk_blockalign(blk, IO_BUF_SIZE);
2649
2650 num_sectors = blk_nb_sectors(blk);
2651 if (num_sectors < 0) {
2652 error_report("Could not get size of '%s': %s",
2653 filename, strerror(-num_sectors));
2654 ret = -1;
2655 goto out;
2656 }
2657 old_backing_num_sectors = blk_nb_sectors(blk_old_backing);
2658 if (old_backing_num_sectors < 0) {
2659 char backing_name[PATH_MAX];
2660
2661 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
2662 error_report("Could not get size of '%s': %s",
2663 backing_name, strerror(-old_backing_num_sectors));
2664 ret = -1;
2665 goto out;
2666 }
2667 if (blk_new_backing) {
2668 new_backing_num_sectors = blk_nb_sectors(blk_new_backing);
2669 if (new_backing_num_sectors < 0) {
2670 error_report("Could not get size of '%s': %s",
2671 out_baseimg, strerror(-new_backing_num_sectors));
2672 ret = -1;
2673 goto out;
2674 }
2675 }
2676
2677 if (num_sectors != 0) {
2678 local_progress = (float)100 /
2679 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
2680 }
2681
2682 for (sector = 0; sector < num_sectors; sector += n) {
2683
2684 /* How many sectors can we handle with the next read? */
2685 if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
2686 n = (IO_BUF_SIZE / 512);
2687 } else {
2688 n = num_sectors - sector;
2689 }
2690
2691 /* If the cluster is allocated, we don't need to take action */
2692 ret = bdrv_is_allocated(bs, sector, n, &n);
2693 if (ret < 0) {
2694 error_report("error while reading image metadata: %s",
2695 strerror(-ret));
2696 goto out;
2697 }
2698 if (ret) {
2699 continue;
2700 }
2701
2702 /*
2703 * Read old and new backing file and take into consideration that
2704 * backing files may be smaller than the COW image.
2705 */
2706 if (sector >= old_backing_num_sectors) {
2707 memset(buf_old, 0, n * BDRV_SECTOR_SIZE);
2708 } else {
2709 if (sector + n > old_backing_num_sectors) {
2710 n = old_backing_num_sectors - sector;
2711 }
2712
2713 ret = blk_read(blk_old_backing, sector, buf_old, n);
2714 if (ret < 0) {
2715 error_report("error while reading from old backing file");
2716 goto out;
2717 }
2718 }
2719
2720 if (sector >= new_backing_num_sectors || !blk_new_backing) {
2721 memset(buf_new, 0, n * BDRV_SECTOR_SIZE);
2722 } else {
2723 if (sector + n > new_backing_num_sectors) {
2724 n = new_backing_num_sectors - sector;
2725 }
2726
2727 ret = blk_read(blk_new_backing, sector, buf_new, n);
2728 if (ret < 0) {
2729 error_report("error while reading from new backing file");
2730 goto out;
2731 }
2732 }
2733
2734 /* If they differ, we need to write to the COW file */
2735 uint64_t written = 0;
2736
2737 while (written < n) {
2738 int pnum;
2739
2740 if (compare_sectors(buf_old + written * 512,
2741 buf_new + written * 512, n - written, &pnum))
2742 {
2743 ret = blk_write(blk, sector + written,
2744 buf_old + written * 512, pnum);
2745 if (ret < 0) {
2746 error_report("Error while writing to COW image: %s",
2747 strerror(-ret));
2748 goto out;
2749 }
2750 }
2751
2752 written += pnum;
2753 }
2754 qemu_progress_print(local_progress, 100);
2755 }
2756
2757 qemu_vfree(buf_old);
2758 qemu_vfree(buf_new);
2759 }
2760
2761 /*
2762 * Change the backing file. All clusters that are different from the old
2763 * backing file are overwritten in the COW file now, so the visible content
2764 * doesn't change when we switch the backing file.
2765 */
2766 if (out_baseimg && *out_baseimg) {
2767 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
2768 } else {
2769 ret = bdrv_change_backing_file(bs, NULL, NULL);
2770 }
2771
2772 if (ret == -ENOSPC) {
2773 error_report("Could not change the backing file to '%s': No "
2774 "space left in the file header", out_baseimg);
2775 } else if (ret < 0) {
2776 error_report("Could not change the backing file to '%s': %s",
2777 out_baseimg, strerror(-ret));
2778 }
2779
2780 qemu_progress_print(100, 0);
2781 /*
2782 * TODO At this point it is possible to check if any clusters that are
2783 * allocated in the COW file are the same in the backing file. If so, they
2784 * could be dropped from the COW file. Don't do this before switching the
2785 * backing file, in case of a crash this would lead to corruption.
2786 */
2787 out:
2788 qemu_progress_end();
2789 /* Cleanup */
2790 if (!unsafe) {
2791 blk_unref(blk_old_backing);
2792 blk_unref(blk_new_backing);
2793 }
2794
2795 blk_unref(blk);
2796 if (ret) {
2797 return 1;
2798 }
2799 return 0;
2800 }
2801
2802 static int img_resize(int argc, char **argv)
2803 {
2804 Error *err = NULL;
2805 int c, ret, relative;
2806 const char *filename, *fmt, *size;
2807 int64_t n, total_size;
2808 bool quiet = false;
2809 BlockBackend *blk = NULL;
2810 QemuOpts *param;
2811 static QemuOptsList resize_options = {
2812 .name = "resize_options",
2813 .head = QTAILQ_HEAD_INITIALIZER(resize_options.head),
2814 .desc = {
2815 {
2816 .name = BLOCK_OPT_SIZE,
2817 .type = QEMU_OPT_SIZE,
2818 .help = "Virtual disk size"
2819 }, {
2820 /* end of list */
2821 }
2822 },
2823 };
2824
2825 /* Remove size from argv manually so that negative numbers are not treated
2826 * as options by getopt. */
2827 if (argc < 3) {
2828 error_exit("Not enough arguments");
2829 return 1;
2830 }
2831
2832 size = argv[--argc];
2833
2834 /* Parse getopt arguments */
2835 fmt = NULL;
2836 for(;;) {
2837 c = getopt(argc, argv, "f:hq");
2838 if (c == -1) {
2839 break;
2840 }
2841 switch(c) {
2842 case '?':
2843 case 'h':
2844 help();
2845 break;
2846 case 'f':
2847 fmt = optarg;
2848 break;
2849 case 'q':
2850 quiet = true;
2851 break;
2852 }
2853 }
2854 if (optind != argc - 1) {
2855 error_exit("Expecting one image file name");
2856 }
2857 filename = argv[optind++];
2858
2859 /* Choose grow, shrink, or absolute resize mode */
2860 switch (size[0]) {
2861 case '+':
2862 relative = 1;
2863 size++;
2864 break;
2865 case '-':
2866 relative = -1;
2867 size++;
2868 break;
2869 default:
2870 relative = 0;
2871 break;
2872 }
2873
2874 /* Parse size */
2875 param = qemu_opts_create(&resize_options, NULL, 0, &error_abort);
2876 qemu_opt_set(param, BLOCK_OPT_SIZE, size, &err);
2877 if (err) {
2878 error_report_err(err);
2879 ret = -1;
2880 qemu_opts_del(param);
2881 goto out;
2882 }
2883 n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
2884 qemu_opts_del(param);
2885
2886 blk = img_open("image", filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR,
2887 true, quiet);
2888 if (!blk) {
2889 ret = -1;
2890 goto out;
2891 }
2892
2893 if (relative) {
2894 total_size = blk_getlength(blk) + n * relative;
2895 } else {
2896 total_size = n;
2897 }
2898 if (total_size <= 0) {
2899 error_report("New image size must be positive");
2900 ret = -1;
2901 goto out;
2902 }
2903
2904 ret = blk_truncate(blk, total_size);
2905 switch (ret) {
2906 case 0:
2907 qprintf(quiet, "Image resized.\n");
2908 break;
2909 case -ENOTSUP:
2910 error_report("This image does not support resize");
2911 break;
2912 case -EACCES:
2913 error_report("Image is read-only");
2914 break;
2915 default:
2916 error_report("Error resizing image (%d)", -ret);
2917 break;
2918 }
2919 out:
2920 blk_unref(blk);
2921 if (ret) {
2922 return 1;
2923 }
2924 return 0;
2925 }
2926
2927 static void amend_status_cb(BlockDriverState *bs,
2928 int64_t offset, int64_t total_work_size,
2929 void *opaque)
2930 {
2931 qemu_progress_print(100.f * offset / total_work_size, 0);
2932 }
2933
2934 static int img_amend(int argc, char **argv)
2935 {
2936 Error *err = NULL;
2937 int c, ret = 0;
2938 char *options = NULL;
2939 QemuOptsList *create_opts = NULL;
2940 QemuOpts *opts = NULL;
2941 const char *fmt = NULL, *filename, *cache;
2942 int flags;
2943 bool quiet = false, progress = false;
2944 BlockBackend *blk = NULL;
2945 BlockDriverState *bs = NULL;
2946
2947 cache = BDRV_DEFAULT_CACHE;
2948 for (;;) {
2949 c = getopt(argc, argv, "ho:f:t:pq");
2950 if (c == -1) {
2951 break;
2952 }
2953
2954 switch (c) {
2955 case 'h':
2956 case '?':
2957 help();
2958 break;
2959 case 'o':
2960 if (!is_valid_option_list(optarg)) {
2961 error_report("Invalid option list: %s", optarg);
2962 ret = -1;
2963 goto out_no_progress;
2964 }
2965 if (!options) {
2966 options = g_strdup(optarg);
2967 } else {
2968 char *old_options = options;
2969 options = g_strdup_printf("%s,%s", options, optarg);
2970 g_free(old_options);
2971 }
2972 break;
2973 case 'f':
2974 fmt = optarg;
2975 break;
2976 case 't':
2977 cache = optarg;
2978 break;
2979 case 'p':
2980 progress = true;
2981 break;
2982 case 'q':
2983 quiet = true;
2984 break;
2985 }
2986 }
2987
2988 if (!options) {
2989 error_exit("Must specify options (-o)");
2990 }
2991
2992 if (quiet) {
2993 progress = false;
2994 }
2995 qemu_progress_init(progress, 1.0);
2996
2997 filename = (optind == argc - 1) ? argv[argc - 1] : NULL;
2998 if (fmt && has_help_option(options)) {
2999 /* If a format is explicitly specified (and possibly no filename is
3000 * given), print option help here */
3001 ret = print_block_option_help(filename, fmt);
3002 goto out;
3003 }
3004
3005 if (optind != argc - 1) {
3006 error_report("Expecting one image file name");
3007 ret = -1;
3008 goto out;
3009 }
3010
3011 flags = BDRV_O_FLAGS | BDRV_O_RDWR;
3012 ret = bdrv_parse_cache_flags(cache, &flags);
3013 if (ret < 0) {
3014 error_report("Invalid cache option: %s", cache);
3015 goto out;
3016 }
3017
3018 blk = img_open("image", filename, fmt, flags, true, quiet);
3019 if (!blk) {
3020 ret = -1;
3021 goto out;
3022 }
3023 bs = blk_bs(blk);
3024
3025 fmt = bs->drv->format_name;
3026
3027 if (has_help_option(options)) {
3028 /* If the format was auto-detected, print option help here */
3029 ret = print_block_option_help(filename, fmt);
3030 goto out;
3031 }
3032
3033 if (!bs->drv->create_opts) {
3034 error_report("Format driver '%s' does not support any options to amend",
3035 fmt);
3036 ret = -1;
3037 goto out;
3038 }
3039
3040 create_opts = qemu_opts_append(create_opts, bs->drv->create_opts);
3041 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
3042 if (options) {
3043 qemu_opts_do_parse(opts, options, NULL, &err);
3044 if (err) {
3045 error_report_err(err);
3046 ret = -1;
3047 goto out;
3048 }
3049 }
3050
3051 /* In case the driver does not call amend_status_cb() */
3052 qemu_progress_print(0.f, 0);
3053 ret = bdrv_amend_options(bs, opts, &amend_status_cb, NULL);
3054 qemu_progress_print(100.f, 0);
3055 if (ret < 0) {
3056 error_report("Error while amending options: %s", strerror(-ret));
3057 goto out;
3058 }
3059
3060 out:
3061 qemu_progress_end();
3062
3063 out_no_progress:
3064 blk_unref(blk);
3065 qemu_opts_del(opts);
3066 qemu_opts_free(create_opts);
3067 g_free(options);
3068
3069 if (ret) {
3070 return 1;
3071 }
3072 return 0;
3073 }
3074
3075 static const img_cmd_t img_cmds[] = {
3076 #define DEF(option, callback, arg_string) \
3077 { option, callback },
3078 #include "qemu-img-cmds.h"
3079 #undef DEF
3080 #undef GEN_DOCS
3081 { NULL, NULL, },
3082 };
3083
3084 int main(int argc, char **argv)
3085 {
3086 const img_cmd_t *cmd;
3087 const char *cmdname;
3088 Error *local_error = NULL;
3089 int c;
3090 static const struct option long_options[] = {
3091 {"help", no_argument, 0, 'h'},
3092 {"version", no_argument, 0, 'v'},
3093 {0, 0, 0, 0}
3094 };
3095
3096 #ifdef CONFIG_POSIX
3097 signal(SIGPIPE, SIG_IGN);
3098 #endif
3099
3100 error_set_progname(argv[0]);
3101 qemu_init_exec_dir(argv[0]);
3102
3103 if (qemu_init_main_loop(&local_error)) {
3104 error_report_err(local_error);
3105 exit(EXIT_FAILURE);
3106 }
3107
3108 bdrv_init();
3109 if (argc < 2) {
3110 error_exit("Not enough arguments");
3111 }
3112 cmdname = argv[1];
3113
3114 /* find the command */
3115 for (cmd = img_cmds; cmd->name != NULL; cmd++) {
3116 if (!strcmp(cmdname, cmd->name)) {
3117 return cmd->handler(argc - 1, argv + 1);
3118 }
3119 }
3120
3121 c = getopt_long(argc, argv, "h", long_options, NULL);
3122
3123 if (c == 'h') {
3124 help();
3125 }
3126 if (c == 'v') {
3127 printf(QEMU_IMG_VERSION);
3128 return 0;
3129 }
3130
3131 /* not found */
3132 error_exit("Command not found: %s", cmdname);
3133 }
armbru's QEMU hackery