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