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