]> git.proxmox.com Git - qemu.git/blame - qemu-img.c
vfio: Add bootindex support
[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"
7b1b5d19 26#include "qapi/qmp/qjson.h"
faf07963 27#include "qemu-common.h"
1de7afc9
PB
28#include "qemu/option.h"
29#include "qemu/error-report.h"
30#include "qemu/osdep.h"
9c17d615 31#include "sysemu/sysemu.h"
737e150e 32#include "block/block_int.h"
c054b3fd 33#include <getopt.h>
9230eaf6 34#include <stdio.h>
f382d43a 35#include <stdarg.h>
ea2384d3 36
e8445331
FB
37#ifdef _WIN32
38#include <windows.h>
39#endif
40
c227f099 41typedef struct img_cmd_t {
153859be
SB
42 const char *name;
43 int (*handler)(int argc, char **argv);
c227f099 44} img_cmd_t;
153859be 45
8599ea4c
FS
46enum {
47 OPTION_OUTPUT = 256,
48 OPTION_BACKING_CHAIN = 257,
49};
50
51typedef enum OutputFormat {
52 OFORMAT_JSON,
53 OFORMAT_HUMAN,
54} OutputFormat;
55
137519ce 56/* Default to cache=writeback as data integrity is not important for qemu-tcg. */
adfe078e 57#define BDRV_O_FLAGS BDRV_O_CACHE_WB
661a0f71 58#define BDRV_DEFAULT_CACHE "writeback"
137519ce 59
ea2384d3
FB
60static void format_print(void *opaque, const char *name)
61{
62 printf(" %s", name);
63}
64
d2c639d6 65/* Please keep in synch with qemu-img.texi */
3f379ab1 66static void help(void)
ea2384d3 67{
e00291c0
PB
68 const char *help_msg =
69 "qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n"
3f020d70 70 "usage: qemu-img command [command options]\n"
71 "QEMU disk image utility\n"
72 "\n"
73 "Command syntax:\n"
153859be
SB
74#define DEF(option, callback, arg_string) \
75 " " arg_string "\n"
76#include "qemu-img-cmds.h"
77#undef DEF
78#undef GEN_DOCS
3f020d70 79 "\n"
80 "Command parameters:\n"
81 " 'filename' is a disk image filename\n"
82 " 'fmt' is the disk image format. It is guessed automatically in most cases\n"
661a0f71 83 " 'cache' is the cache mode used to write the output disk image, the valid\n"
80ccf93b
LY
84 " options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n"
85 " 'directsync' and 'unsafe' (default for convert)\n"
3f020d70 86 " 'size' is the disk image size in bytes. Optional suffixes\n"
87 " 'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n"
88 " and T (terabyte, 1024G) are supported. 'b' is ignored.\n"
89 " 'output_filename' is the destination disk image filename\n"
90 " 'output_fmt' is the destination format\n"
91 " 'options' is a comma separated list of format specific options in a\n"
92 " name=value format. Use -o ? for an overview of the options supported by the\n"
93 " used format\n"
94 " '-c' indicates that target image must be compressed (qcow format only)\n"
95 " '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
96 " match exactly. The image doesn't need a working backing file before\n"
97 " rebasing in this case (useful for renaming the backing file)\n"
98 " '-h' with or without a command shows this help and lists the supported formats\n"
6b837bc4 99 " '-p' show progress of command (only certain commands)\n"
f382d43a 100 " '-q' use Quiet mode - do not print any output (except errors)\n"
a22f123c
KW
101 " '-S' indicates the consecutive number of bytes that must contain only zeros\n"
102 " for qemu-img to create a sparse image during conversion\n"
c054b3fd 103 " '--output' takes the format in which the output must be done (human or json)\n"
3f020d70 104 "\n"
4534ff54
KW
105 "Parameters to check subcommand:\n"
106 " '-r' tries to repair any inconsistencies that are found during the check.\n"
107 " '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n"
108 " kinds of errors, with a higher risk of choosing the wrong fix or\n"
0546b8c2 109 " hiding corruption that has already occurred.\n"
4534ff54 110 "\n"
3f020d70 111 "Parameters to snapshot subcommand:\n"
112 " 'snapshot' is the name of the snapshot to create, apply or delete\n"
113 " '-a' applies a snapshot (revert disk to saved state)\n"
114 " '-c' creates a snapshot\n"
115 " '-d' deletes a snapshot\n"
d14ed18c
MR
116 " '-l' lists all snapshots in the given image\n"
117 "\n"
118 "Parameters to compare subcommand:\n"
119 " '-f' first image format\n"
120 " '-F' second image format\n"
121 " '-s' run in Strict mode - fail on different image size or sector allocation\n";
e00291c0
PB
122
123 printf("%s\nSupported formats:", help_msg);
ea2384d3
FB
124 bdrv_iterate_format(format_print, NULL);
125 printf("\n");
126 exit(1);
127}
128
f382d43a
MR
129static int qprintf(bool quiet, const char *fmt, ...)
130{
131 int ret = 0;
132 if (!quiet) {
133 va_list args;
134 va_start(args, fmt);
135 ret = vprintf(fmt, args);
136 va_end(args);
137 }
138 return ret;
139}
140
ea2384d3
FB
141#if defined(WIN32)
142/* XXX: put correct support for win32 */
143static int read_password(char *buf, int buf_size)
144{
145 int c, i;
146 printf("Password: ");
147 fflush(stdout);
148 i = 0;
149 for(;;) {
150 c = getchar();
151 if (c == '\n')
152 break;
153 if (i < (buf_size - 1))
154 buf[i++] = c;
155 }
156 buf[i] = '\0';
157 return 0;
158}
159
160#else
161
162#include <termios.h>
163
164static struct termios oldtty;
165
166static void term_exit(void)
167{
168 tcsetattr (0, TCSANOW, &oldtty);
169}
170
171static void term_init(void)
172{
173 struct termios tty;
174
175 tcgetattr (0, &tty);
176 oldtty = tty;
177
178 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
179 |INLCR|IGNCR|ICRNL|IXON);
180 tty.c_oflag |= OPOST;
181 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
182 tty.c_cflag &= ~(CSIZE|PARENB);
183 tty.c_cflag |= CS8;
184 tty.c_cc[VMIN] = 1;
185 tty.c_cc[VTIME] = 0;
3b46e624 186
ea2384d3
FB
187 tcsetattr (0, TCSANOW, &tty);
188
189 atexit(term_exit);
190}
191
3f379ab1 192static int read_password(char *buf, int buf_size)
ea2384d3
FB
193{
194 uint8_t ch;
195 int i, ret;
196
197 printf("password: ");
198 fflush(stdout);
199 term_init();
200 i = 0;
201 for(;;) {
202 ret = read(0, &ch, 1);
203 if (ret == -1) {
204 if (errno == EAGAIN || errno == EINTR) {
205 continue;
206 } else {
207 ret = -1;
208 break;
209 }
210 } else if (ret == 0) {
211 ret = -1;
212 break;
213 } else {
214 if (ch == '\r') {
215 ret = 0;
216 break;
217 }
218 if (i < (buf_size - 1))
219 buf[i++] = ch;
220 }
221 }
222 term_exit();
223 buf[i] = '\0';
224 printf("\n");
225 return ret;
226}
227#endif
228
4ac8aacd
JS
229static int print_block_option_help(const char *filename, const char *fmt)
230{
231 BlockDriver *drv, *proto_drv;
232 QEMUOptionParameter *create_options = NULL;
233
234 /* Find driver and parse its options */
235 drv = bdrv_find_format(fmt);
236 if (!drv) {
15654a6d 237 error_report("Unknown file format '%s'", fmt);
4ac8aacd
JS
238 return 1;
239 }
240
241 proto_drv = bdrv_find_protocol(filename);
242 if (!proto_drv) {
15654a6d 243 error_report("Unknown protocol '%s'", filename);
4ac8aacd
JS
244 return 1;
245 }
246
247 create_options = append_option_parameters(create_options,
248 drv->create_options);
249 create_options = append_option_parameters(create_options,
250 proto_drv->create_options);
251 print_option_help(create_options);
252 free_option_parameters(create_options);
253 return 0;
254}
255
75c23805 256static BlockDriverState *bdrv_new_open(const char *filename,
9bc378c1 257 const char *fmt,
f0536bb8 258 int flags,
f382d43a
MR
259 bool require_io,
260 bool quiet)
75c23805
FB
261{
262 BlockDriverState *bs;
263 BlockDriver *drv;
264 char password[256];
b9eaf9ec 265 int ret;
75c23805 266
b9eaf9ec 267 bs = bdrv_new("image");
ad717139 268
75c23805
FB
269 if (fmt) {
270 drv = bdrv_find_format(fmt);
c2abccec 271 if (!drv) {
15654a6d 272 error_report("Unknown file format '%s'", fmt);
c2abccec
MK
273 goto fail;
274 }
75c23805
FB
275 } else {
276 drv = NULL;
277 }
b9eaf9ec 278
de9c0cec 279 ret = bdrv_open(bs, filename, NULL, flags, drv);
b9eaf9ec
KW
280 if (ret < 0) {
281 error_report("Could not open '%s': %s", filename, strerror(-ret));
c2abccec 282 goto fail;
75c23805 283 }
b9eaf9ec 284
f0536bb8 285 if (bdrv_is_encrypted(bs) && require_io) {
f382d43a 286 qprintf(quiet, "Disk image '%s' is encrypted.\n", filename);
c2abccec 287 if (read_password(password, sizeof(password)) < 0) {
15654a6d 288 error_report("No password given");
c2abccec
MK
289 goto fail;
290 }
291 if (bdrv_set_key(bs, password) < 0) {
15654a6d 292 error_report("invalid password");
c2abccec
MK
293 goto fail;
294 }
75c23805
FB
295 }
296 return bs;
c2abccec
MK
297fail:
298 if (bs) {
299 bdrv_delete(bs);
300 }
301 return NULL;
75c23805
FB
302}
303
c2abccec 304static int add_old_style_options(const char *fmt, QEMUOptionParameter *list,
eec77d9e
JS
305 const char *base_filename,
306 const char *base_fmt)
efa84d43 307{
efa84d43
KW
308 if (base_filename) {
309 if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) {
15654a6d
JS
310 error_report("Backing file not supported for file format '%s'",
311 fmt);
c2abccec 312 return -1;
efa84d43
KW
313 }
314 }
315 if (base_fmt) {
316 if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) {
15654a6d
JS
317 error_report("Backing file format not supported for file "
318 "format '%s'", fmt);
c2abccec 319 return -1;
efa84d43
KW
320 }
321 }
c2abccec 322 return 0;
efa84d43
KW
323}
324
ea2384d3
FB
325static int img_create(int argc, char **argv)
326{
a9300911 327 int c;
1da7cfbd 328 uint64_t img_size = -1;
ea2384d3 329 const char *fmt = "raw";
9230eaf6 330 const char *base_fmt = NULL;
ea2384d3
FB
331 const char *filename;
332 const char *base_filename = NULL;
9ea2ea71 333 char *options = NULL;
9b37525a 334 Error *local_err = NULL;
f382d43a 335 bool quiet = false;
3b46e624 336
ea2384d3 337 for(;;) {
f382d43a 338 c = getopt(argc, argv, "F:b:f:he6o:q");
b8fb60da 339 if (c == -1) {
ea2384d3 340 break;
b8fb60da 341 }
ea2384d3 342 switch(c) {
ef87394c 343 case '?':
ea2384d3
FB
344 case 'h':
345 help();
346 break;
9230eaf6
AL
347 case 'F':
348 base_fmt = optarg;
349 break;
ea2384d3
FB
350 case 'b':
351 base_filename = optarg;
352 break;
353 case 'f':
354 fmt = optarg;
355 break;
356 case 'e':
9d42e15d 357 error_report("option -e is deprecated, please use \'-o "
eec77d9e
JS
358 "encryption\' instead!");
359 return 1;
d8871c5a 360 case '6':
9d42e15d 361 error_report("option -6 is deprecated, please use \'-o "
eec77d9e
JS
362 "compat6\' instead!");
363 return 1;
9ea2ea71
KW
364 case 'o':
365 options = optarg;
366 break;
f382d43a
MR
367 case 'q':
368 quiet = true;
369 break;
ea2384d3
FB
370 }
371 }
9230eaf6 372
b50cbabc 373 /* Get the filename */
b8fb60da 374 if (optind >= argc) {
b50cbabc 375 help();
b8fb60da 376 }
b50cbabc
MK
377 filename = argv[optind++];
378
1da7cfbd
JS
379 /* Get image size, if specified */
380 if (optind < argc) {
70b4f4bb 381 int64_t sval;
e36b3695
MA
382 char *end;
383 sval = strtosz_suffix(argv[optind++], &end, STRTOSZ_DEFSUFFIX_B);
384 if (sval < 0 || *end) {
79443397 385 if (sval == -ERANGE) {
386 error_report("Image size must be less than 8 EiB!");
387 } else {
388 error_report("Invalid image size specified! You may use k, M, "
389 "G or T suffixes for ");
390 error_report("kilobytes, megabytes, gigabytes and terabytes.");
391 }
a9300911 392 return 1;
1da7cfbd
JS
393 }
394 img_size = (uint64_t)sval;
395 }
396
c8057f95 397 if (options && is_help_option(options)) {
a9300911 398 return print_block_option_help(filename, fmt);
4ac8aacd
JS
399 }
400
9b37525a 401 bdrv_img_create(filename, fmt, base_filename, base_fmt,
f382d43a 402 options, img_size, BDRV_O_FLAGS, &local_err, quiet);
9b37525a
LC
403 if (error_is_set(&local_err)) {
404 error_report("%s", error_get_pretty(local_err));
405 error_free(local_err);
c2abccec
MK
406 return 1;
407 }
a9300911 408
ea2384d3
FB
409 return 0;
410}
411
f382d43a 412static void dump_json_image_check(ImageCheck *check, bool quiet)
8599ea4c
FS
413{
414 Error *errp = NULL;
415 QString *str;
416 QmpOutputVisitor *ov = qmp_output_visitor_new();
417 QObject *obj;
418 visit_type_ImageCheck(qmp_output_get_visitor(ov),
419 &check, NULL, &errp);
420 obj = qmp_output_get_qobject(ov);
421 str = qobject_to_json_pretty(obj);
422 assert(str != NULL);
f382d43a 423 qprintf(quiet, "%s\n", qstring_get_str(str));
8599ea4c
FS
424 qobject_decref(obj);
425 qmp_output_visitor_cleanup(ov);
426 QDECREF(str);
427}
428
f382d43a 429static void dump_human_image_check(ImageCheck *check, bool quiet)
8599ea4c
FS
430{
431 if (!(check->corruptions || check->leaks || check->check_errors)) {
f382d43a 432 qprintf(quiet, "No errors were found on the image.\n");
8599ea4c
FS
433 } else {
434 if (check->corruptions) {
f382d43a
MR
435 qprintf(quiet, "\n%" PRId64 " errors were found on the image.\n"
436 "Data may be corrupted, or further writes to the image "
437 "may corrupt it.\n",
438 check->corruptions);
8599ea4c
FS
439 }
440
441 if (check->leaks) {
f382d43a
MR
442 qprintf(quiet,
443 "\n%" PRId64 " leaked clusters were found on the image.\n"
444 "This means waste of disk space, but no harm to data.\n",
445 check->leaks);
8599ea4c
FS
446 }
447
448 if (check->check_errors) {
f382d43a
MR
449 qprintf(quiet,
450 "\n%" PRId64
451 " internal errors have occurred during the check.\n",
452 check->check_errors);
8599ea4c
FS
453 }
454 }
455
456 if (check->total_clusters != 0 && check->allocated_clusters != 0) {
f382d43a
MR
457 qprintf(quiet, "%" PRId64 "/%" PRId64 " = %0.2f%% allocated, "
458 "%0.2f%% fragmented, %0.2f%% compressed clusters\n",
459 check->allocated_clusters, check->total_clusters,
460 check->allocated_clusters * 100.0 / check->total_clusters,
461 check->fragmented_clusters * 100.0 / check->allocated_clusters,
462 check->compressed_clusters * 100.0 /
463 check->allocated_clusters);
8599ea4c
FS
464 }
465
466 if (check->image_end_offset) {
f382d43a
MR
467 qprintf(quiet,
468 "Image end offset: %" PRId64 "\n", check->image_end_offset);
8599ea4c
FS
469 }
470}
471
472static int collect_image_check(BlockDriverState *bs,
473 ImageCheck *check,
474 const char *filename,
475 const char *fmt,
476 int fix)
477{
478 int ret;
479 BdrvCheckResult result;
480
481 ret = bdrv_check(bs, &result, fix);
482 if (ret < 0) {
483 return ret;
484 }
485
486 check->filename = g_strdup(filename);
487 check->format = g_strdup(bdrv_get_format_name(bs));
488 check->check_errors = result.check_errors;
489 check->corruptions = result.corruptions;
490 check->has_corruptions = result.corruptions != 0;
491 check->leaks = result.leaks;
492 check->has_leaks = result.leaks != 0;
493 check->corruptions_fixed = result.corruptions_fixed;
494 check->has_corruptions_fixed = result.corruptions != 0;
495 check->leaks_fixed = result.leaks_fixed;
496 check->has_leaks_fixed = result.leaks != 0;
497 check->image_end_offset = result.image_end_offset;
498 check->has_image_end_offset = result.image_end_offset != 0;
499 check->total_clusters = result.bfi.total_clusters;
500 check->has_total_clusters = result.bfi.total_clusters != 0;
501 check->allocated_clusters = result.bfi.allocated_clusters;
502 check->has_allocated_clusters = result.bfi.allocated_clusters != 0;
503 check->fragmented_clusters = result.bfi.fragmented_clusters;
504 check->has_fragmented_clusters = result.bfi.fragmented_clusters != 0;
e6439d78
SH
505 check->compressed_clusters = result.bfi.compressed_clusters;
506 check->has_compressed_clusters = result.bfi.compressed_clusters != 0;
8599ea4c
FS
507
508 return 0;
509}
510
e076f338
KW
511/*
512 * Checks an image for consistency. Exit codes:
513 *
514 * 0 - Check completed, image is good
515 * 1 - Check not completed because of internal errors
516 * 2 - Check completed, image is corrupted
517 * 3 - Check completed, image has leaked clusters, but is good otherwise
518 */
1585969c
AL
519static int img_check(int argc, char **argv)
520{
521 int c, ret;
8599ea4c
FS
522 OutputFormat output_format = OFORMAT_HUMAN;
523 const char *filename, *fmt, *output;
1585969c 524 BlockDriverState *bs;
4534ff54 525 int fix = 0;
058f8f16 526 int flags = BDRV_O_FLAGS | BDRV_O_CHECK;
8599ea4c 527 ImageCheck *check;
f382d43a 528 bool quiet = false;
1585969c
AL
529
530 fmt = NULL;
8599ea4c 531 output = NULL;
1585969c 532 for(;;) {
8599ea4c
FS
533 int option_index = 0;
534 static const struct option long_options[] = {
535 {"help", no_argument, 0, 'h'},
536 {"format", required_argument, 0, 'f'},
537 {"repair", no_argument, 0, 'r'},
538 {"output", required_argument, 0, OPTION_OUTPUT},
539 {0, 0, 0, 0}
540 };
f382d43a 541 c = getopt_long(argc, argv, "f:hr:q",
8599ea4c 542 long_options, &option_index);
b8fb60da 543 if (c == -1) {
1585969c 544 break;
b8fb60da 545 }
1585969c 546 switch(c) {
ef87394c 547 case '?':
1585969c
AL
548 case 'h':
549 help();
550 break;
551 case 'f':
552 fmt = optarg;
553 break;
4534ff54
KW
554 case 'r':
555 flags |= BDRV_O_RDWR;
556
557 if (!strcmp(optarg, "leaks")) {
558 fix = BDRV_FIX_LEAKS;
559 } else if (!strcmp(optarg, "all")) {
560 fix = BDRV_FIX_LEAKS | BDRV_FIX_ERRORS;
561 } else {
562 help();
563 }
564 break;
8599ea4c
FS
565 case OPTION_OUTPUT:
566 output = optarg;
567 break;
f382d43a
MR
568 case 'q':
569 quiet = true;
570 break;
1585969c
AL
571 }
572 }
b8fb60da 573 if (optind >= argc) {
1585969c 574 help();
b8fb60da 575 }
1585969c
AL
576 filename = argv[optind++];
577
8599ea4c
FS
578 if (output && !strcmp(output, "json")) {
579 output_format = OFORMAT_JSON;
580 } else if (output && !strcmp(output, "human")) {
581 output_format = OFORMAT_HUMAN;
582 } else if (output) {
583 error_report("--output must be used with human or json as argument.");
584 return 1;
585 }
586
f382d43a 587 bs = bdrv_new_open(filename, fmt, flags, true, quiet);
c2abccec
MK
588 if (!bs) {
589 return 1;
590 }
8599ea4c
FS
591
592 check = g_new0(ImageCheck, 1);
593 ret = collect_image_check(bs, check, filename, fmt, fix);
e076f338
KW
594
595 if (ret == -ENOTSUP) {
8599ea4c
FS
596 if (output_format == OFORMAT_HUMAN) {
597 error_report("This image format does not support checks");
598 }
599 ret = 1;
600 goto fail;
e076f338
KW
601 }
602
8599ea4c
FS
603 if (check->corruptions_fixed || check->leaks_fixed) {
604 int corruptions_fixed, leaks_fixed;
ccf34716 605
8599ea4c
FS
606 leaks_fixed = check->leaks_fixed;
607 corruptions_fixed = check->corruptions_fixed;
e076f338 608
8599ea4c 609 if (output_format == OFORMAT_HUMAN) {
f382d43a
MR
610 qprintf(quiet,
611 "The following inconsistencies were found and repaired:\n\n"
612 " %" PRId64 " leaked clusters\n"
613 " %" PRId64 " corruptions\n\n"
614 "Double checking the fixed image now...\n",
615 check->leaks_fixed,
616 check->corruptions_fixed);
e076f338
KW
617 }
618
8599ea4c 619 ret = collect_image_check(bs, check, filename, fmt, 0);
1585969c 620
8599ea4c
FS
621 check->leaks_fixed = leaks_fixed;
622 check->corruptions_fixed = corruptions_fixed;
f8111c24
DXW
623 }
624
8599ea4c
FS
625 switch (output_format) {
626 case OFORMAT_HUMAN:
f382d43a 627 dump_human_image_check(check, quiet);
8599ea4c
FS
628 break;
629 case OFORMAT_JSON:
f382d43a 630 dump_json_image_check(check, quiet);
8599ea4c 631 break;
c6bb9ad1
FS
632 }
633
8599ea4c
FS
634 if (ret || check->check_errors) {
635 ret = 1;
636 goto fail;
c2abccec 637 }
e076f338 638
8599ea4c
FS
639 if (check->corruptions) {
640 ret = 2;
641 } else if (check->leaks) {
642 ret = 3;
e076f338 643 } else {
8599ea4c 644 ret = 0;
e076f338 645 }
8599ea4c
FS
646
647fail:
648 qapi_free_ImageCheck(check);
649 bdrv_delete(bs);
650
651 return ret;
1585969c
AL
652}
653
ea2384d3
FB
654static int img_commit(int argc, char **argv)
655{
661a0f71
FS
656 int c, ret, flags;
657 const char *filename, *fmt, *cache;
ea2384d3 658 BlockDriverState *bs;
f382d43a 659 bool quiet = false;
ea2384d3
FB
660
661 fmt = NULL;
661a0f71 662 cache = BDRV_DEFAULT_CACHE;
ea2384d3 663 for(;;) {
f382d43a 664 c = getopt(argc, argv, "f:ht:q");
b8fb60da 665 if (c == -1) {
ea2384d3 666 break;
b8fb60da 667 }
ea2384d3 668 switch(c) {
ef87394c 669 case '?':
ea2384d3
FB
670 case 'h':
671 help();
672 break;
673 case 'f':
674 fmt = optarg;
675 break;
661a0f71
FS
676 case 't':
677 cache = optarg;
678 break;
f382d43a
MR
679 case 'q':
680 quiet = true;
681 break;
ea2384d3
FB
682 }
683 }
b8fb60da 684 if (optind >= argc) {
ea2384d3 685 help();
b8fb60da 686 }
ea2384d3
FB
687 filename = argv[optind++];
688
661a0f71 689 flags = BDRV_O_RDWR;
c3993cdc 690 ret = bdrv_parse_cache_flags(cache, &flags);
661a0f71
FS
691 if (ret < 0) {
692 error_report("Invalid cache option: %s", cache);
693 return -1;
694 }
695
f382d43a 696 bs = bdrv_new_open(filename, fmt, flags, true, quiet);
c2abccec
MK
697 if (!bs) {
698 return 1;
699 }
ea2384d3
FB
700 ret = bdrv_commit(bs);
701 switch(ret) {
702 case 0:
f382d43a 703 qprintf(quiet, "Image committed.\n");
ea2384d3
FB
704 break;
705 case -ENOENT:
15654a6d 706 error_report("No disk inserted");
ea2384d3
FB
707 break;
708 case -EACCES:
15654a6d 709 error_report("Image is read-only");
ea2384d3
FB
710 break;
711 case -ENOTSUP:
15654a6d 712 error_report("Image is already committed");
ea2384d3
FB
713 break;
714 default:
15654a6d 715 error_report("Error while committing image");
ea2384d3
FB
716 break;
717 }
718
719 bdrv_delete(bs);
c2abccec
MK
720 if (ret) {
721 return 1;
722 }
ea2384d3
FB
723 return 0;
724}
725
f58c7b35
TS
726/*
727 * Returns true iff the first sector pointed to by 'buf' contains at least
728 * a non-NUL byte.
729 *
730 * 'pnum' is set to the number of sectors (including and immediately following
731 * the first one) that are known to be in the same allocated/unallocated state.
732 */
ea2384d3
FB
733static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
734{
1a6d39fd
SH
735 bool is_zero;
736 int i;
ea2384d3
FB
737
738 if (n <= 0) {
739 *pnum = 0;
740 return 0;
741 }
1a6d39fd 742 is_zero = buffer_is_zero(buf, 512);
ea2384d3
FB
743 for(i = 1; i < n; i++) {
744 buf += 512;
1a6d39fd 745 if (is_zero != buffer_is_zero(buf, 512)) {
ea2384d3 746 break;
1a6d39fd 747 }
ea2384d3
FB
748 }
749 *pnum = i;
1a6d39fd 750 return !is_zero;
ea2384d3
FB
751}
752
a22f123c
KW
753/*
754 * Like is_allocated_sectors, but if the buffer starts with a used sector,
755 * up to 'min' consecutive sectors containing zeros are ignored. This avoids
756 * breaking up write requests for only small sparse areas.
757 */
758static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
759 int min)
760{
761 int ret;
762 int num_checked, num_used;
763
764 if (n < min) {
765 min = n;
766 }
767
768 ret = is_allocated_sectors(buf, n, pnum);
769 if (!ret) {
770 return ret;
771 }
772
773 num_used = *pnum;
774 buf += BDRV_SECTOR_SIZE * *pnum;
775 n -= *pnum;
776 num_checked = num_used;
777
778 while (n > 0) {
779 ret = is_allocated_sectors(buf, n, pnum);
780
781 buf += BDRV_SECTOR_SIZE * *pnum;
782 n -= *pnum;
783 num_checked += *pnum;
784 if (ret) {
785 num_used = num_checked;
786 } else if (*pnum >= min) {
787 break;
788 }
789 }
790
791 *pnum = num_used;
792 return 1;
793}
794
3e85c6fd
KW
795/*
796 * Compares two buffers sector by sector. Returns 0 if the first sector of both
797 * buffers matches, non-zero otherwise.
798 *
799 * pnum is set to the number of sectors (including and immediately following
800 * the first one) that are known to have the same comparison result
801 */
802static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
803 int *pnum)
804{
805 int res, i;
806
807 if (n <= 0) {
808 *pnum = 0;
809 return 0;
810 }
811
812 res = !!memcmp(buf1, buf2, 512);
813 for(i = 1; i < n; i++) {
814 buf1 += 512;
815 buf2 += 512;
816
817 if (!!memcmp(buf1, buf2, 512) != res) {
818 break;
819 }
820 }
821
822 *pnum = i;
823 return res;
824}
825
80ee15a6 826#define IO_BUF_SIZE (2 * 1024 * 1024)
ea2384d3 827
d14ed18c
MR
828static int64_t sectors_to_bytes(int64_t sectors)
829{
830 return sectors << BDRV_SECTOR_BITS;
831}
832
833static int64_t sectors_to_process(int64_t total, int64_t from)
834{
835 return MIN(total - from, IO_BUF_SIZE >> BDRV_SECTOR_BITS);
836}
837
838/*
839 * Check if passed sectors are empty (not allocated or contain only 0 bytes)
840 *
841 * Returns 0 in case sectors are filled with 0, 1 if sectors contain non-zero
842 * data and negative value on error.
843 *
844 * @param bs: Driver used for accessing file
845 * @param sect_num: Number of first sector to check
846 * @param sect_count: Number of sectors to check
847 * @param filename: Name of disk file we are checking (logging purpose)
848 * @param buffer: Allocated buffer for storing read data
849 * @param quiet: Flag for quiet mode
850 */
851static int check_empty_sectors(BlockDriverState *bs, int64_t sect_num,
852 int sect_count, const char *filename,
853 uint8_t *buffer, bool quiet)
854{
855 int pnum, ret = 0;
856 ret = bdrv_read(bs, sect_num, buffer, sect_count);
857 if (ret < 0) {
858 error_report("Error while reading offset %" PRId64 " of %s: %s",
859 sectors_to_bytes(sect_num), filename, strerror(-ret));
860 return ret;
861 }
862 ret = is_allocated_sectors(buffer, sect_count, &pnum);
863 if (ret || pnum != sect_count) {
864 qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
865 sectors_to_bytes(ret ? sect_num : sect_num + pnum));
866 return 1;
867 }
868
869 return 0;
870}
871
872/*
873 * Compares two images. Exit codes:
874 *
875 * 0 - Images are identical
876 * 1 - Images differ
877 * >1 - Error occurred
878 */
879static int img_compare(int argc, char **argv)
880{
881 const char *fmt1 = NULL, *fmt2 = NULL, *filename1, *filename2;
882 BlockDriverState *bs1, *bs2;
883 int64_t total_sectors1, total_sectors2;
884 uint8_t *buf1 = NULL, *buf2 = NULL;
885 int pnum1, pnum2;
886 int allocated1, allocated2;
887 int ret = 0; /* return value - 0 Ident, 1 Different, >1 Error */
888 bool progress = false, quiet = false, strict = false;
889 int64_t total_sectors;
890 int64_t sector_num = 0;
891 int64_t nb_sectors;
892 int c, pnum;
893 uint64_t bs_sectors;
894 uint64_t progress_base;
895
896 for (;;) {
897 c = getopt(argc, argv, "hpf:F:sq");
898 if (c == -1) {
899 break;
900 }
901 switch (c) {
902 case '?':
903 case 'h':
904 help();
905 break;
906 case 'f':
907 fmt1 = optarg;
908 break;
909 case 'F':
910 fmt2 = optarg;
911 break;
912 case 'p':
913 progress = true;
914 break;
915 case 'q':
916 quiet = true;
917 break;
918 case 's':
919 strict = true;
920 break;
921 }
922 }
923
924 /* Progress is not shown in Quiet mode */
925 if (quiet) {
926 progress = false;
927 }
928
929
930 if (optind > argc - 2) {
931 help();
932 }
933 filename1 = argv[optind++];
934 filename2 = argv[optind++];
935
936 /* Initialize before goto out */
937 qemu_progress_init(progress, 2.0);
938
939 bs1 = bdrv_new_open(filename1, fmt1, BDRV_O_FLAGS, true, quiet);
940 if (!bs1) {
941 error_report("Can't open file %s", filename1);
942 ret = 2;
943 goto out3;
944 }
945
946 bs2 = bdrv_new_open(filename2, fmt2, BDRV_O_FLAGS, true, quiet);
947 if (!bs2) {
948 error_report("Can't open file %s", filename2);
949 ret = 2;
950 goto out2;
951 }
952
953 buf1 = qemu_blockalign(bs1, IO_BUF_SIZE);
954 buf2 = qemu_blockalign(bs2, IO_BUF_SIZE);
955 bdrv_get_geometry(bs1, &bs_sectors);
956 total_sectors1 = bs_sectors;
957 bdrv_get_geometry(bs2, &bs_sectors);
958 total_sectors2 = bs_sectors;
959 total_sectors = MIN(total_sectors1, total_sectors2);
960 progress_base = MAX(total_sectors1, total_sectors2);
961
962 qemu_progress_print(0, 100);
963
964 if (strict && total_sectors1 != total_sectors2) {
965 ret = 1;
966 qprintf(quiet, "Strict mode: Image size mismatch!\n");
967 goto out;
968 }
969
970 for (;;) {
971 nb_sectors = sectors_to_process(total_sectors, sector_num);
972 if (nb_sectors <= 0) {
973 break;
974 }
975 allocated1 = bdrv_is_allocated_above(bs1, NULL, sector_num, nb_sectors,
976 &pnum1);
977 if (allocated1 < 0) {
978 ret = 3;
979 error_report("Sector allocation test failed for %s", filename1);
980 goto out;
981 }
982
983 allocated2 = bdrv_is_allocated_above(bs2, NULL, sector_num, nb_sectors,
984 &pnum2);
985 if (allocated2 < 0) {
986 ret = 3;
987 error_report("Sector allocation test failed for %s", filename2);
988 goto out;
989 }
990 nb_sectors = MIN(pnum1, pnum2);
991
992 if (allocated1 == allocated2) {
993 if (allocated1) {
994 ret = bdrv_read(bs1, sector_num, buf1, nb_sectors);
995 if (ret < 0) {
996 error_report("Error while reading offset %" PRId64 " of %s:"
997 " %s", sectors_to_bytes(sector_num), filename1,
998 strerror(-ret));
999 ret = 4;
1000 goto out;
1001 }
1002 ret = bdrv_read(bs2, sector_num, buf2, nb_sectors);
1003 if (ret < 0) {
1004 error_report("Error while reading offset %" PRId64
1005 " of %s: %s", sectors_to_bytes(sector_num),
1006 filename2, strerror(-ret));
1007 ret = 4;
1008 goto out;
1009 }
1010 ret = compare_sectors(buf1, buf2, nb_sectors, &pnum);
1011 if (ret || pnum != nb_sectors) {
1012 ret = 1;
1013 qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
1014 sectors_to_bytes(
1015 ret ? sector_num : sector_num + pnum));
1016 goto out;
1017 }
1018 }
1019 } else {
1020 if (strict) {
1021 ret = 1;
1022 qprintf(quiet, "Strict mode: Offset %" PRId64
1023 " allocation mismatch!\n",
1024 sectors_to_bytes(sector_num));
1025 goto out;
1026 }
1027
1028 if (allocated1) {
1029 ret = check_empty_sectors(bs1, sector_num, nb_sectors,
1030 filename1, buf1, quiet);
1031 } else {
1032 ret = check_empty_sectors(bs2, sector_num, nb_sectors,
1033 filename2, buf1, quiet);
1034 }
1035 if (ret) {
1036 if (ret < 0) {
1037 ret = 4;
1038 error_report("Error while reading offset %" PRId64 ": %s",
1039 sectors_to_bytes(sector_num), strerror(-ret));
1040 }
1041 goto out;
1042 }
1043 }
1044 sector_num += nb_sectors;
1045 qemu_progress_print(((float) nb_sectors / progress_base)*100, 100);
1046 }
1047
1048 if (total_sectors1 != total_sectors2) {
1049 BlockDriverState *bs_over;
1050 int64_t total_sectors_over;
1051 const char *filename_over;
1052
1053 qprintf(quiet, "Warning: Image size mismatch!\n");
1054 if (total_sectors1 > total_sectors2) {
1055 total_sectors_over = total_sectors1;
1056 bs_over = bs1;
1057 filename_over = filename1;
1058 } else {
1059 total_sectors_over = total_sectors2;
1060 bs_over = bs2;
1061 filename_over = filename2;
1062 }
1063
1064 for (;;) {
1065 nb_sectors = sectors_to_process(total_sectors_over, sector_num);
1066 if (nb_sectors <= 0) {
1067 break;
1068 }
1069 ret = bdrv_is_allocated_above(bs_over, NULL, sector_num,
1070 nb_sectors, &pnum);
1071 if (ret < 0) {
1072 ret = 3;
1073 error_report("Sector allocation test failed for %s",
1074 filename_over);
1075 goto out;
1076
1077 }
1078 nb_sectors = pnum;
1079 if (ret) {
1080 ret = check_empty_sectors(bs_over, sector_num, nb_sectors,
1081 filename_over, buf1, quiet);
1082 if (ret) {
1083 if (ret < 0) {
1084 ret = 4;
1085 error_report("Error while reading offset %" PRId64
1086 " of %s: %s", sectors_to_bytes(sector_num),
1087 filename_over, strerror(-ret));
1088 }
1089 goto out;
1090 }
1091 }
1092 sector_num += nb_sectors;
1093 qemu_progress_print(((float) nb_sectors / progress_base)*100, 100);
1094 }
1095 }
1096
1097 qprintf(quiet, "Images are identical.\n");
1098 ret = 0;
1099
1100out:
1101 bdrv_delete(bs2);
1102 qemu_vfree(buf1);
1103 qemu_vfree(buf2);
1104out2:
1105 bdrv_delete(bs1);
1106out3:
1107 qemu_progress_end();
1108 return ret;
1109}
1110
ea2384d3
FB
1111static int img_convert(int argc, char **argv)
1112{
eec77d9e 1113 int c, ret = 0, n, n1, bs_n, bs_i, compress, cluster_size, cluster_sectors;
661a0f71
FS
1114 int progress = 0, flags;
1115 const char *fmt, *out_fmt, *cache, *out_baseimg, *out_filename;
b50cbabc 1116 BlockDriver *drv, *proto_drv;
c2abccec 1117 BlockDriverState **bs = NULL, *out_bs = NULL;
96b8f136
TS
1118 int64_t total_sectors, nb_sectors, sector_num, bs_offset;
1119 uint64_t bs_sectors;
c2abccec 1120 uint8_t * buf = NULL;
ea2384d3 1121 const uint8_t *buf1;
faea38e7 1122 BlockDriverInfo bdi;
b50cbabc 1123 QEMUOptionParameter *param = NULL, *create_options = NULL;
a18953fb 1124 QEMUOptionParameter *out_baseimg_param;
efa84d43 1125 char *options = NULL;
51ef6727 1126 const char *snapshot_name = NULL;
1f710495 1127 float local_progress = 0;
a22f123c 1128 int min_sparse = 8; /* Need at least 4k of zeros for sparse detection */
f382d43a 1129 bool quiet = false;
ea2384d3
FB
1130
1131 fmt = NULL;
1132 out_fmt = "raw";
661a0f71 1133 cache = "unsafe";
f58c7b35 1134 out_baseimg = NULL;
eec77d9e 1135 compress = 0;
ea2384d3 1136 for(;;) {
f382d43a 1137 c = getopt(argc, argv, "f:O:B:s:hce6o:pS:t:q");
b8fb60da 1138 if (c == -1) {
ea2384d3 1139 break;
b8fb60da 1140 }
ea2384d3 1141 switch(c) {
ef87394c 1142 case '?':
ea2384d3
FB
1143 case 'h':
1144 help();
1145 break;
1146 case 'f':
1147 fmt = optarg;
1148 break;
1149 case 'O':
1150 out_fmt = optarg;
1151 break;
f58c7b35
TS
1152 case 'B':
1153 out_baseimg = optarg;
1154 break;
ea2384d3 1155 case 'c':
eec77d9e 1156 compress = 1;
ea2384d3
FB
1157 break;
1158 case 'e':
9d42e15d 1159 error_report("option -e is deprecated, please use \'-o "
eec77d9e
JS
1160 "encryption\' instead!");
1161 return 1;
ec36ba14 1162 case '6':
9d42e15d 1163 error_report("option -6 is deprecated, please use \'-o "
eec77d9e
JS
1164 "compat6\' instead!");
1165 return 1;
efa84d43
KW
1166 case 'o':
1167 options = optarg;
1168 break;
51ef6727 1169 case 's':
1170 snapshot_name = optarg;
1171 break;
a22f123c
KW
1172 case 'S':
1173 {
1174 int64_t sval;
e36b3695
MA
1175 char *end;
1176 sval = strtosz_suffix(optarg, &end, STRTOSZ_DEFSUFFIX_B);
1177 if (sval < 0 || *end) {
a22f123c
KW
1178 error_report("Invalid minimum zero buffer size for sparse output specified");
1179 return 1;
1180 }
1181
1182 min_sparse = sval / BDRV_SECTOR_SIZE;
1183 break;
1184 }
6b837bc4
JS
1185 case 'p':
1186 progress = 1;
1187 break;
661a0f71
FS
1188 case 't':
1189 cache = optarg;
1190 break;
f382d43a
MR
1191 case 'q':
1192 quiet = true;
1193 break;
ea2384d3
FB
1194 }
1195 }
3b46e624 1196
f382d43a
MR
1197 if (quiet) {
1198 progress = 0;
1199 }
1200
926c2d23 1201 bs_n = argc - optind - 1;
b8fb60da
JS
1202 if (bs_n < 1) {
1203 help();
1204 }
926c2d23
AZ
1205
1206 out_filename = argv[argc - 1];
f58c7b35 1207
fa170c14
CA
1208 /* Initialize before goto out */
1209 qemu_progress_init(progress, 2.0);
1210
c8057f95 1211 if (options && is_help_option(options)) {
4ac8aacd
JS
1212 ret = print_block_option_help(out_filename, out_fmt);
1213 goto out;
1214 }
1215
c2abccec 1216 if (bs_n > 1 && out_baseimg) {
15654a6d
JS
1217 error_report("-B makes no sense when concatenating multiple input "
1218 "images");
31ca34b8
JS
1219 ret = -1;
1220 goto out;
c2abccec 1221 }
f8111c24 1222
6b837bc4
JS
1223 qemu_progress_print(0, 100);
1224
7267c094 1225 bs = g_malloc0(bs_n * sizeof(BlockDriverState *));
926c2d23
AZ
1226
1227 total_sectors = 0;
1228 for (bs_i = 0; bs_i < bs_n; bs_i++) {
f382d43a
MR
1229 bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, BDRV_O_FLAGS, true,
1230 quiet);
c2abccec 1231 if (!bs[bs_i]) {
15654a6d 1232 error_report("Could not open '%s'", argv[optind + bs_i]);
c2abccec
MK
1233 ret = -1;
1234 goto out;
1235 }
926c2d23
AZ
1236 bdrv_get_geometry(bs[bs_i], &bs_sectors);
1237 total_sectors += bs_sectors;
1238 }
ea2384d3 1239
51ef6727 1240 if (snapshot_name != NULL) {
1241 if (bs_n > 1) {
6daf194d 1242 error_report("No support for concatenating multiple snapshot");
51ef6727 1243 ret = -1;
1244 goto out;
1245 }
1246 if (bdrv_snapshot_load_tmp(bs[0], snapshot_name) < 0) {
6daf194d 1247 error_report("Failed to load snapshot");
51ef6727 1248 ret = -1;
1249 goto out;
1250 }
1251 }
1252
efa84d43 1253 /* Find driver and parse its options */
ea2384d3 1254 drv = bdrv_find_format(out_fmt);
c2abccec 1255 if (!drv) {
15654a6d 1256 error_report("Unknown file format '%s'", out_fmt);
c2abccec
MK
1257 ret = -1;
1258 goto out;
1259 }
efa84d43 1260
b50cbabc 1261 proto_drv = bdrv_find_protocol(out_filename);
c2abccec 1262 if (!proto_drv) {
15654a6d 1263 error_report("Unknown protocol '%s'", out_filename);
c2abccec
MK
1264 ret = -1;
1265 goto out;
1266 }
b50cbabc
MK
1267
1268 create_options = append_option_parameters(create_options,
1269 drv->create_options);
1270 create_options = append_option_parameters(create_options,
1271 proto_drv->create_options);
db08adf5 1272
efa84d43 1273 if (options) {
b50cbabc 1274 param = parse_option_parameters(options, create_options, param);
efa84d43 1275 if (param == NULL) {
15654a6d 1276 error_report("Invalid options for file format '%s'.", out_fmt);
c2abccec
MK
1277 ret = -1;
1278 goto out;
efa84d43
KW
1279 }
1280 } else {
b50cbabc 1281 param = parse_option_parameters("", create_options, param);
efa84d43
KW
1282 }
1283
1284 set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
eec77d9e 1285 ret = add_old_style_options(out_fmt, param, out_baseimg, NULL);
c2abccec
MK
1286 if (ret < 0) {
1287 goto out;
1288 }
efa84d43 1289
a18953fb
KW
1290 /* Get backing file name if -o backing_file was used */
1291 out_baseimg_param = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
1292 if (out_baseimg_param) {
1293 out_baseimg = out_baseimg_param->value.s;
1294 }
1295
efa84d43 1296 /* Check if compression is supported */
eec77d9e 1297 if (compress) {
efa84d43
KW
1298 QEMUOptionParameter *encryption =
1299 get_option_parameter(param, BLOCK_OPT_ENCRYPT);
41521fa4
KW
1300 QEMUOptionParameter *preallocation =
1301 get_option_parameter(param, BLOCK_OPT_PREALLOC);
efa84d43
KW
1302
1303 if (!drv->bdrv_write_compressed) {
15654a6d 1304 error_report("Compression not supported for this file format");
c2abccec
MK
1305 ret = -1;
1306 goto out;
efa84d43
KW
1307 }
1308
1309 if (encryption && encryption->value.n) {
15654a6d
JS
1310 error_report("Compression and encryption not supported at "
1311 "the same time");
c2abccec
MK
1312 ret = -1;
1313 goto out;
efa84d43 1314 }
41521fa4
KW
1315
1316 if (preallocation && preallocation->value.s
1317 && strcmp(preallocation->value.s, "off"))
1318 {
1319 error_report("Compression and preallocation not supported at "
1320 "the same time");
1321 ret = -1;
1322 goto out;
1323 }
efa84d43
KW
1324 }
1325
1326 /* Create the new image */
1327 ret = bdrv_create(drv, out_filename, param);
ea2384d3
FB
1328 if (ret < 0) {
1329 if (ret == -ENOTSUP) {
15654a6d
JS
1330 error_report("Formatting not supported for file format '%s'",
1331 out_fmt);
6e9ea0c0 1332 } else if (ret == -EFBIG) {
15654a6d
JS
1333 error_report("The image size is too large for file format '%s'",
1334 out_fmt);
ea2384d3 1335 } else {
15654a6d
JS
1336 error_report("%s: error while converting %s: %s",
1337 out_filename, out_fmt, strerror(-ret));
ea2384d3 1338 }
c2abccec 1339 goto out;
ea2384d3 1340 }
3b46e624 1341
661a0f71 1342 flags = BDRV_O_RDWR;
c3993cdc 1343 ret = bdrv_parse_cache_flags(cache, &flags);
661a0f71
FS
1344 if (ret < 0) {
1345 error_report("Invalid cache option: %s", cache);
1346 return -1;
1347 }
1348
f382d43a 1349 out_bs = bdrv_new_open(out_filename, out_fmt, flags, true, quiet);
c2abccec
MK
1350 if (!out_bs) {
1351 ret = -1;
1352 goto out;
1353 }
ea2384d3 1354
926c2d23
AZ
1355 bs_i = 0;
1356 bs_offset = 0;
1357 bdrv_get_geometry(bs[0], &bs_sectors);
bb1c0597 1358 buf = qemu_blockalign(out_bs, IO_BUF_SIZE);
926c2d23 1359
eec77d9e 1360 if (compress) {
c2abccec
MK
1361 ret = bdrv_get_info(out_bs, &bdi);
1362 if (ret < 0) {
15654a6d 1363 error_report("could not get block driver info");
c2abccec
MK
1364 goto out;
1365 }
faea38e7 1366 cluster_size = bdi.cluster_size;
c2abccec 1367 if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) {
15654a6d 1368 error_report("invalid cluster size");
c2abccec
MK
1369 ret = -1;
1370 goto out;
1371 }
ea2384d3
FB
1372 cluster_sectors = cluster_size >> 9;
1373 sector_num = 0;
6b837bc4
JS
1374
1375 nb_sectors = total_sectors;
1f710495
KW
1376 if (nb_sectors != 0) {
1377 local_progress = (float)100 /
1378 (nb_sectors / MIN(nb_sectors, cluster_sectors));
1379 }
6b837bc4 1380
ea2384d3 1381 for(;;) {
926c2d23
AZ
1382 int64_t bs_num;
1383 int remainder;
1384 uint8_t *buf2;
1385
ea2384d3
FB
1386 nb_sectors = total_sectors - sector_num;
1387 if (nb_sectors <= 0)
1388 break;
1389 if (nb_sectors >= cluster_sectors)
1390 n = cluster_sectors;
1391 else
1392 n = nb_sectors;
926c2d23
AZ
1393
1394 bs_num = sector_num - bs_offset;
1395 assert (bs_num >= 0);
1396 remainder = n;
1397 buf2 = buf;
1398 while (remainder > 0) {
1399 int nlow;
1400 while (bs_num == bs_sectors) {
1401 bs_i++;
1402 assert (bs_i < bs_n);
1403 bs_offset += bs_sectors;
1404 bdrv_get_geometry(bs[bs_i], &bs_sectors);
1405 bs_num = 0;
0bfcd599
BS
1406 /* printf("changing part: sector_num=%" PRId64 ", "
1407 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
1408 "\n", sector_num, bs_i, bs_offset, bs_sectors); */
926c2d23
AZ
1409 }
1410 assert (bs_num < bs_sectors);
1411
1412 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;
1413
c2abccec
MK
1414 ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow);
1415 if (ret < 0) {
3fba9d81
SH
1416 error_report("error while reading sector %" PRId64 ": %s",
1417 bs_num, strerror(-ret));
c2abccec
MK
1418 goto out;
1419 }
926c2d23
AZ
1420
1421 buf2 += nlow * 512;
1422 bs_num += nlow;
1423
1424 remainder -= nlow;
1425 }
1426 assert (remainder == 0);
1427
b8fb60da 1428 if (n < cluster_sectors) {
ea2384d3 1429 memset(buf + n * 512, 0, cluster_size - n * 512);
b8fb60da 1430 }
1a6d39fd 1431 if (!buffer_is_zero(buf, cluster_size)) {
c2abccec
MK
1432 ret = bdrv_write_compressed(out_bs, sector_num, buf,
1433 cluster_sectors);
1434 if (ret != 0) {
3fba9d81
SH
1435 error_report("error while compressing sector %" PRId64
1436 ": %s", sector_num, strerror(-ret));
c2abccec
MK
1437 goto out;
1438 }
ea2384d3
FB
1439 }
1440 sector_num += n;
6b837bc4 1441 qemu_progress_print(local_progress, 100);
ea2384d3 1442 }
faea38e7
FB
1443 /* signal EOF to align */
1444 bdrv_write_compressed(out_bs, 0, NULL, 0);
ea2384d3 1445 } else {
f2feebbd
KW
1446 int has_zero_init = bdrv_has_zero_init(out_bs);
1447
f58c7b35 1448 sector_num = 0; // total number of sectors converted so far
6b837bc4 1449 nb_sectors = total_sectors - sector_num;
1f710495
KW
1450 if (nb_sectors != 0) {
1451 local_progress = (float)100 /
1452 (nb_sectors / MIN(nb_sectors, IO_BUF_SIZE / 512));
1453 }
6b837bc4 1454
ea2384d3
FB
1455 for(;;) {
1456 nb_sectors = total_sectors - sector_num;
b8fb60da 1457 if (nb_sectors <= 0) {
ea2384d3 1458 break;
b8fb60da
JS
1459 }
1460 if (nb_sectors >= (IO_BUF_SIZE / 512)) {
ea2384d3 1461 n = (IO_BUF_SIZE / 512);
b8fb60da 1462 } else {
ea2384d3 1463 n = nb_sectors;
b8fb60da 1464 }
926c2d23
AZ
1465
1466 while (sector_num - bs_offset >= bs_sectors) {
1467 bs_i ++;
1468 assert (bs_i < bs_n);
1469 bs_offset += bs_sectors;
1470 bdrv_get_geometry(bs[bs_i], &bs_sectors);
0bfcd599
BS
1471 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
1472 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
926c2d23
AZ
1473 sector_num, bs_i, bs_offset, bs_sectors); */
1474 }
1475
b8fb60da 1476 if (n > bs_offset + bs_sectors - sector_num) {
926c2d23 1477 n = bs_offset + bs_sectors - sector_num;
b8fb60da 1478 }
926c2d23 1479
f2feebbd 1480 if (has_zero_init) {
d032044f
AS
1481 /* If the output image is being created as a copy on write image,
1482 assume that sectors which are unallocated in the input image
1483 are present in both the output's and input's base images (no
1484 need to copy them). */
1485 if (out_baseimg) {
1486 if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
1487 n, &n1)) {
1488 sector_num += n1;
1489 continue;
1490 }
1491 /* The next 'n1' sectors are allocated in the input image. Copy
1492 only those as they may be followed by unallocated sectors. */
1493 n = n1;
93c65b47 1494 }
93c65b47
AL
1495 } else {
1496 n1 = n;
f58c7b35
TS
1497 }
1498
c2abccec
MK
1499 ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
1500 if (ret < 0) {
3fba9d81
SH
1501 error_report("error while reading sector %" PRId64 ": %s",
1502 sector_num - bs_offset, strerror(-ret));
c2abccec
MK
1503 goto out;
1504 }
ea2384d3
FB
1505 /* NOTE: at the same time we convert, we do not write zero
1506 sectors to have a chance to compress the image. Ideally, we
1507 should add a specific call to have the info to go faster */
1508 buf1 = buf;
1509 while (n > 0) {
f58c7b35
TS
1510 /* If the output image is being created as a copy on write image,
1511 copy all sectors even the ones containing only NUL bytes,
93c65b47
AL
1512 because they may differ from the sectors in the base image.
1513
1514 If the output is to a host device, we also write out
1515 sectors that are entirely 0, since whatever data was
1516 already there is garbage, not 0s. */
f2feebbd 1517 if (!has_zero_init || out_baseimg ||
a22f123c 1518 is_allocated_sectors_min(buf1, n, &n1, min_sparse)) {
c2abccec
MK
1519 ret = bdrv_write(out_bs, sector_num, buf1, n1);
1520 if (ret < 0) {
3fba9d81
SH
1521 error_report("error while writing sector %" PRId64
1522 ": %s", sector_num, strerror(-ret));
c2abccec
MK
1523 goto out;
1524 }
ea2384d3
FB
1525 }
1526 sector_num += n1;
1527 n -= n1;
1528 buf1 += n1 * 512;
1529 }
6b837bc4 1530 qemu_progress_print(local_progress, 100);
ea2384d3
FB
1531 }
1532 }
c2abccec 1533out:
6b837bc4 1534 qemu_progress_end();
c2abccec
MK
1535 free_option_parameters(create_options);
1536 free_option_parameters(param);
bb1c0597 1537 qemu_vfree(buf);
c2abccec
MK
1538 if (out_bs) {
1539 bdrv_delete(out_bs);
1540 }
31ca34b8
JS
1541 if (bs) {
1542 for (bs_i = 0; bs_i < bs_n; bs_i++) {
1543 if (bs[bs_i]) {
1544 bdrv_delete(bs[bs_i]);
1545 }
c2abccec 1546 }
7267c094 1547 g_free(bs);
c2abccec 1548 }
c2abccec
MK
1549 if (ret) {
1550 return 1;
1551 }
ea2384d3
FB
1552 return 0;
1553}
1554
57d1a2b6 1555
faea38e7
FB
1556static void dump_snapshots(BlockDriverState *bs)
1557{
1558 QEMUSnapshotInfo *sn_tab, *sn;
1559 int nb_sns, i;
1560 char buf[256];
1561
1562 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1563 if (nb_sns <= 0)
1564 return;
1565 printf("Snapshot list:\n");
1566 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
1567 for(i = 0; i < nb_sns; i++) {
1568 sn = &sn_tab[i];
1569 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
1570 }
7267c094 1571 g_free(sn_tab);
faea38e7
FB
1572}
1573
9699bf0d
SH
1574static void dump_json_image_info_list(ImageInfoList *list)
1575{
1576 Error *errp = NULL;
1577 QString *str;
1578 QmpOutputVisitor *ov = qmp_output_visitor_new();
1579 QObject *obj;
1580 visit_type_ImageInfoList(qmp_output_get_visitor(ov),
1581 &list, NULL, &errp);
1582 obj = qmp_output_get_qobject(ov);
1583 str = qobject_to_json_pretty(obj);
1584 assert(str != NULL);
1585 printf("%s\n", qstring_get_str(str));
1586 qobject_decref(obj);
1587 qmp_output_visitor_cleanup(ov);
1588 QDECREF(str);
1589}
1590
c054b3fd
BC
1591static void collect_snapshots(BlockDriverState *bs , ImageInfo *info)
1592{
1593 int i, sn_count;
1594 QEMUSnapshotInfo *sn_tab = NULL;
1595 SnapshotInfoList *info_list, *cur_item = NULL;
1596 sn_count = bdrv_snapshot_list(bs, &sn_tab);
1597
1598 for (i = 0; i < sn_count; i++) {
1599 info->has_snapshots = true;
1600 info_list = g_new0(SnapshotInfoList, 1);
1601
1602 info_list->value = g_new0(SnapshotInfo, 1);
1603 info_list->value->id = g_strdup(sn_tab[i].id_str);
1604 info_list->value->name = g_strdup(sn_tab[i].name);
1605 info_list->value->vm_state_size = sn_tab[i].vm_state_size;
1606 info_list->value->date_sec = sn_tab[i].date_sec;
1607 info_list->value->date_nsec = sn_tab[i].date_nsec;
1608 info_list->value->vm_clock_sec = sn_tab[i].vm_clock_nsec / 1000000000;
1609 info_list->value->vm_clock_nsec = sn_tab[i].vm_clock_nsec % 1000000000;
1610
1611 /* XXX: waiting for the qapi to support qemu-queue.h types */
1612 if (!cur_item) {
1613 info->snapshots = cur_item = info_list;
1614 } else {
1615 cur_item->next = info_list;
1616 cur_item = info_list;
1617 }
1618
1619 }
1620
1621 g_free(sn_tab);
1622}
1623
1624static void dump_json_image_info(ImageInfo *info)
1625{
1626 Error *errp = NULL;
1627 QString *str;
1628 QmpOutputVisitor *ov = qmp_output_visitor_new();
1629 QObject *obj;
1630 visit_type_ImageInfo(qmp_output_get_visitor(ov),
1631 &info, NULL, &errp);
1632 obj = qmp_output_get_qobject(ov);
1633 str = qobject_to_json_pretty(obj);
1634 assert(str != NULL);
1635 printf("%s\n", qstring_get_str(str));
1636 qobject_decref(obj);
1637 qmp_output_visitor_cleanup(ov);
1638 QDECREF(str);
1639}
1640
1641static void collect_image_info(BlockDriverState *bs,
1642 ImageInfo *info,
1643 const char *filename,
1644 const char *fmt)
ea2384d3 1645{
96b8f136 1646 uint64_t total_sectors;
93b6b2a3
FB
1647 char backing_filename[1024];
1648 char backing_filename2[1024];
faea38e7 1649 BlockDriverInfo bdi;
ea2384d3 1650
c054b3fd
BC
1651 bdrv_get_geometry(bs, &total_sectors);
1652
1653 info->filename = g_strdup(filename);
1654 info->format = g_strdup(bdrv_get_format_name(bs));
1655 info->virtual_size = total_sectors * 512;
1656 info->actual_size = bdrv_get_allocated_file_size(bs);
1657 info->has_actual_size = info->actual_size >= 0;
1658 if (bdrv_is_encrypted(bs)) {
1659 info->encrypted = true;
1660 info->has_encrypted = true;
1661 }
1662 if (bdrv_get_info(bs, &bdi) >= 0) {
1663 if (bdi.cluster_size != 0) {
1664 info->cluster_size = bdi.cluster_size;
1665 info->has_cluster_size = true;
1666 }
1667 info->dirty_flag = bdi.is_dirty;
1668 info->has_dirty_flag = true;
1669 }
1670 bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
1671 if (backing_filename[0] != '\0') {
1672 info->backing_filename = g_strdup(backing_filename);
1673 info->has_backing_filename = true;
1674 bdrv_get_full_backing_filename(bs, backing_filename2,
1675 sizeof(backing_filename2));
1676
1677 if (strcmp(backing_filename, backing_filename2) != 0) {
1678 info->full_backing_filename =
1679 g_strdup(backing_filename2);
1680 info->has_full_backing_filename = true;
1681 }
1682
1683 if (bs->backing_format[0]) {
1684 info->backing_filename_format = g_strdup(bs->backing_format);
1685 info->has_backing_filename_format = true;
1686 }
1687 }
1688}
1689
1690static void dump_human_image_info(ImageInfo *info)
1691{
1692 char size_buf[128], dsize_buf[128];
1693 if (!info->has_actual_size) {
1694 snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
1695 } else {
1696 get_human_readable_size(dsize_buf, sizeof(dsize_buf),
1697 info->actual_size);
1698 }
1699 get_human_readable_size(size_buf, sizeof(size_buf), info->virtual_size);
1700 printf("image: %s\n"
1701 "file format: %s\n"
1702 "virtual size: %s (%" PRId64 " bytes)\n"
1703 "disk size: %s\n",
1704 info->filename, info->format, size_buf,
1705 info->virtual_size,
1706 dsize_buf);
1707
1708 if (info->has_encrypted && info->encrypted) {
1709 printf("encrypted: yes\n");
1710 }
1711
1712 if (info->has_cluster_size) {
1713 printf("cluster_size: %" PRId64 "\n", info->cluster_size);
1714 }
1715
1716 if (info->has_dirty_flag && info->dirty_flag) {
1717 printf("cleanly shut down: no\n");
1718 }
1719
1720 if (info->has_backing_filename) {
1721 printf("backing file: %s", info->backing_filename);
1722 if (info->has_full_backing_filename) {
1723 printf(" (actual path: %s)", info->full_backing_filename);
1724 }
1725 putchar('\n');
1726 if (info->has_backing_filename_format) {
1727 printf("backing file format: %s\n", info->backing_filename_format);
1728 }
1729 }
9699bf0d
SH
1730
1731 if (info->has_snapshots) {
1732 SnapshotInfoList *elem;
1733 char buf[256];
1734
1735 printf("Snapshot list:\n");
1736 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
1737
1738 /* Ideally bdrv_snapshot_dump() would operate on SnapshotInfoList but
1739 * we convert to the block layer's native QEMUSnapshotInfo for now.
1740 */
1741 for (elem = info->snapshots; elem; elem = elem->next) {
1742 QEMUSnapshotInfo sn = {
1743 .vm_state_size = elem->value->vm_state_size,
1744 .date_sec = elem->value->date_sec,
1745 .date_nsec = elem->value->date_nsec,
1746 .vm_clock_nsec = elem->value->vm_clock_sec * 1000000000ULL +
1747 elem->value->vm_clock_nsec,
1748 };
1749
1750 pstrcpy(sn.id_str, sizeof(sn.id_str), elem->value->id);
1751 pstrcpy(sn.name, sizeof(sn.name), elem->value->name);
1752 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), &sn));
1753 }
1754 }
c054b3fd
BC
1755}
1756
9699bf0d
SH
1757static void dump_human_image_info_list(ImageInfoList *list)
1758{
1759 ImageInfoList *elem;
1760 bool delim = false;
1761
1762 for (elem = list; elem; elem = elem->next) {
1763 if (delim) {
1764 printf("\n");
1765 }
1766 delim = true;
1767
1768 dump_human_image_info(elem->value);
1769 }
1770}
1771
1772static gboolean str_equal_func(gconstpointer a, gconstpointer b)
1773{
1774 return strcmp(a, b) == 0;
1775}
1776
1777/**
1778 * Open an image file chain and return an ImageInfoList
1779 *
1780 * @filename: topmost image filename
1781 * @fmt: topmost image format (may be NULL to autodetect)
1782 * @chain: true - enumerate entire backing file chain
1783 * false - only topmost image file
1784 *
1785 * Returns a list of ImageInfo objects or NULL if there was an error opening an
1786 * image file. If there was an error a message will have been printed to
1787 * stderr.
1788 */
1789static ImageInfoList *collect_image_info_list(const char *filename,
1790 const char *fmt,
1791 bool chain)
1792{
1793 ImageInfoList *head = NULL;
1794 ImageInfoList **last = &head;
1795 GHashTable *filenames;
1796
1797 filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL);
1798
1799 while (filename) {
1800 BlockDriverState *bs;
1801 ImageInfo *info;
1802 ImageInfoList *elem;
1803
1804 if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) {
1805 error_report("Backing file '%s' creates an infinite loop.",
1806 filename);
1807 goto err;
1808 }
1809 g_hash_table_insert(filenames, (gpointer)filename, NULL);
1810
1811 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING,
f382d43a 1812 false, false);
9699bf0d
SH
1813 if (!bs) {
1814 goto err;
1815 }
1816
1817 info = g_new0(ImageInfo, 1);
1818 collect_image_info(bs, info, filename, fmt);
1819 collect_snapshots(bs, info);
1820
1821 elem = g_new0(ImageInfoList, 1);
1822 elem->value = info;
1823 *last = elem;
1824 last = &elem->next;
1825
1826 bdrv_delete(bs);
1827
1828 filename = fmt = NULL;
1829 if (chain) {
1830 if (info->has_full_backing_filename) {
1831 filename = info->full_backing_filename;
1832 } else if (info->has_backing_filename) {
1833 filename = info->backing_filename;
1834 }
1835 if (info->has_backing_filename_format) {
1836 fmt = info->backing_filename_format;
1837 }
1838 }
1839 }
1840 g_hash_table_destroy(filenames);
1841 return head;
1842
1843err:
1844 qapi_free_ImageInfoList(head);
1845 g_hash_table_destroy(filenames);
1846 return NULL;
1847}
1848
c054b3fd
BC
1849static int img_info(int argc, char **argv)
1850{
1851 int c;
1852 OutputFormat output_format = OFORMAT_HUMAN;
9699bf0d 1853 bool chain = false;
c054b3fd 1854 const char *filename, *fmt, *output;
9699bf0d 1855 ImageInfoList *list;
c054b3fd 1856
ea2384d3 1857 fmt = NULL;
c054b3fd 1858 output = NULL;
ea2384d3 1859 for(;;) {
c054b3fd
BC
1860 int option_index = 0;
1861 static const struct option long_options[] = {
1862 {"help", no_argument, 0, 'h'},
1863 {"format", required_argument, 0, 'f'},
1864 {"output", required_argument, 0, OPTION_OUTPUT},
9699bf0d 1865 {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN},
c054b3fd
BC
1866 {0, 0, 0, 0}
1867 };
1868 c = getopt_long(argc, argv, "f:h",
1869 long_options, &option_index);
b8fb60da 1870 if (c == -1) {
ea2384d3 1871 break;
b8fb60da 1872 }
ea2384d3 1873 switch(c) {
ef87394c 1874 case '?':
ea2384d3
FB
1875 case 'h':
1876 help();
1877 break;
1878 case 'f':
1879 fmt = optarg;
1880 break;
c054b3fd
BC
1881 case OPTION_OUTPUT:
1882 output = optarg;
1883 break;
9699bf0d
SH
1884 case OPTION_BACKING_CHAIN:
1885 chain = true;
1886 break;
ea2384d3
FB
1887 }
1888 }
b8fb60da 1889 if (optind >= argc) {
ea2384d3 1890 help();
b8fb60da 1891 }
ea2384d3
FB
1892 filename = argv[optind++];
1893
c054b3fd
BC
1894 if (output && !strcmp(output, "json")) {
1895 output_format = OFORMAT_JSON;
1896 } else if (output && !strcmp(output, "human")) {
1897 output_format = OFORMAT_HUMAN;
1898 } else if (output) {
1899 error_report("--output must be used with human or json as argument.");
c2abccec
MK
1900 return 1;
1901 }
c054b3fd 1902
9699bf0d
SH
1903 list = collect_image_info_list(filename, fmt, chain);
1904 if (!list) {
c2abccec 1905 return 1;
faea38e7 1906 }
c054b3fd 1907
c054b3fd
BC
1908 switch (output_format) {
1909 case OFORMAT_HUMAN:
9699bf0d 1910 dump_human_image_info_list(list);
c054b3fd
BC
1911 break;
1912 case OFORMAT_JSON:
9699bf0d
SH
1913 if (chain) {
1914 dump_json_image_info_list(list);
1915 } else {
1916 dump_json_image_info(list->value);
1917 }
c054b3fd 1918 break;
faea38e7 1919 }
c054b3fd 1920
9699bf0d 1921 qapi_free_ImageInfoList(list);
ea2384d3
FB
1922 return 0;
1923}
1924
f7b4a940
AL
1925#define SNAPSHOT_LIST 1
1926#define SNAPSHOT_CREATE 2
1927#define SNAPSHOT_APPLY 3
1928#define SNAPSHOT_DELETE 4
1929
153859be 1930static int img_snapshot(int argc, char **argv)
f7b4a940
AL
1931{
1932 BlockDriverState *bs;
1933 QEMUSnapshotInfo sn;
1934 char *filename, *snapshot_name = NULL;
c2abccec 1935 int c, ret = 0, bdrv_oflags;
f7b4a940
AL
1936 int action = 0;
1937 qemu_timeval tv;
f382d43a 1938 bool quiet = false;
f7b4a940 1939
710da702 1940 bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
f7b4a940
AL
1941 /* Parse commandline parameters */
1942 for(;;) {
f382d43a 1943 c = getopt(argc, argv, "la:c:d:hq");
b8fb60da 1944 if (c == -1) {
f7b4a940 1945 break;
b8fb60da 1946 }
f7b4a940 1947 switch(c) {
ef87394c 1948 case '?':
f7b4a940
AL
1949 case 'h':
1950 help();
153859be 1951 return 0;
f7b4a940
AL
1952 case 'l':
1953 if (action) {
1954 help();
153859be 1955 return 0;
f7b4a940
AL
1956 }
1957 action = SNAPSHOT_LIST;
f5edb014 1958 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
f7b4a940
AL
1959 break;
1960 case 'a':
1961 if (action) {
1962 help();
153859be 1963 return 0;
f7b4a940
AL
1964 }
1965 action = SNAPSHOT_APPLY;
1966 snapshot_name = optarg;
1967 break;
1968 case 'c':
1969 if (action) {
1970 help();
153859be 1971 return 0;
f7b4a940
AL
1972 }
1973 action = SNAPSHOT_CREATE;
1974 snapshot_name = optarg;
1975 break;
1976 case 'd':
1977 if (action) {
1978 help();
153859be 1979 return 0;
f7b4a940
AL
1980 }
1981 action = SNAPSHOT_DELETE;
1982 snapshot_name = optarg;
1983 break;
f382d43a
MR
1984 case 'q':
1985 quiet = true;
1986 break;
f7b4a940
AL
1987 }
1988 }
1989
b8fb60da 1990 if (optind >= argc) {
f7b4a940 1991 help();
b8fb60da 1992 }
f7b4a940
AL
1993 filename = argv[optind++];
1994
1995 /* Open the image */
f382d43a 1996 bs = bdrv_new_open(filename, NULL, bdrv_oflags, true, quiet);
c2abccec
MK
1997 if (!bs) {
1998 return 1;
1999 }
f7b4a940
AL
2000
2001 /* Perform the requested action */
2002 switch(action) {
2003 case SNAPSHOT_LIST:
2004 dump_snapshots(bs);
2005 break;
2006
2007 case SNAPSHOT_CREATE:
2008 memset(&sn, 0, sizeof(sn));
2009 pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
2010
2011 qemu_gettimeofday(&tv);
2012 sn.date_sec = tv.tv_sec;
2013 sn.date_nsec = tv.tv_usec * 1000;
2014
2015 ret = bdrv_snapshot_create(bs, &sn);
b8fb60da 2016 if (ret) {
15654a6d 2017 error_report("Could not create snapshot '%s': %d (%s)",
f7b4a940 2018 snapshot_name, ret, strerror(-ret));
b8fb60da 2019 }
f7b4a940
AL
2020 break;
2021
2022 case SNAPSHOT_APPLY:
2023 ret = bdrv_snapshot_goto(bs, snapshot_name);
b8fb60da 2024 if (ret) {
15654a6d 2025 error_report("Could not apply snapshot '%s': %d (%s)",
f7b4a940 2026 snapshot_name, ret, strerror(-ret));
b8fb60da 2027 }
f7b4a940
AL
2028 break;
2029
2030 case SNAPSHOT_DELETE:
2031 ret = bdrv_snapshot_delete(bs, snapshot_name);
b8fb60da 2032 if (ret) {
15654a6d 2033 error_report("Could not delete snapshot '%s': %d (%s)",
f7b4a940 2034 snapshot_name, ret, strerror(-ret));
b8fb60da 2035 }
f7b4a940
AL
2036 break;
2037 }
2038
2039 /* Cleanup */
2040 bdrv_delete(bs);
c2abccec
MK
2041 if (ret) {
2042 return 1;
2043 }
153859be 2044 return 0;
f7b4a940
AL
2045}
2046
3e85c6fd
KW
2047static int img_rebase(int argc, char **argv)
2048{
c2abccec 2049 BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
f163d073 2050 BlockDriver *old_backing_drv, *new_backing_drv;
3e85c6fd 2051 char *filename;
661a0f71 2052 const char *fmt, *cache, *out_basefmt, *out_baseimg;
3e85c6fd
KW
2053 int c, flags, ret;
2054 int unsafe = 0;
6b837bc4 2055 int progress = 0;
f382d43a 2056 bool quiet = false;
3e85c6fd
KW
2057
2058 /* Parse commandline parameters */
e53dbee0 2059 fmt = NULL;
661a0f71 2060 cache = BDRV_DEFAULT_CACHE;
3e85c6fd
KW
2061 out_baseimg = NULL;
2062 out_basefmt = NULL;
3e85c6fd 2063 for(;;) {
f382d43a 2064 c = getopt(argc, argv, "uhf:F:b:pt:q");
b8fb60da 2065 if (c == -1) {
3e85c6fd 2066 break;
b8fb60da 2067 }
3e85c6fd 2068 switch(c) {
ef87394c 2069 case '?':
3e85c6fd
KW
2070 case 'h':
2071 help();
2072 return 0;
e53dbee0
KW
2073 case 'f':
2074 fmt = optarg;
2075 break;
3e85c6fd
KW
2076 case 'F':
2077 out_basefmt = optarg;
2078 break;
2079 case 'b':
2080 out_baseimg = optarg;
2081 break;
2082 case 'u':
2083 unsafe = 1;
2084 break;
6b837bc4
JS
2085 case 'p':
2086 progress = 1;
2087 break;
661a0f71
FS
2088 case 't':
2089 cache = optarg;
2090 break;
f382d43a
MR
2091 case 'q':
2092 quiet = true;
2093 break;
3e85c6fd
KW
2094 }
2095 }
2096
f382d43a
MR
2097 if (quiet) {
2098 progress = 0;
2099 }
2100
9a9d9dba 2101 if ((optind >= argc) || (!unsafe && !out_baseimg)) {
3e85c6fd 2102 help();
b8fb60da 2103 }
3e85c6fd
KW
2104 filename = argv[optind++];
2105
6b837bc4
JS
2106 qemu_progress_init(progress, 2.0);
2107 qemu_progress_print(0, 100);
2108
661a0f71 2109 flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
c3993cdc 2110 ret = bdrv_parse_cache_flags(cache, &flags);
661a0f71
FS
2111 if (ret < 0) {
2112 error_report("Invalid cache option: %s", cache);
2113 return -1;
2114 }
2115
3e85c6fd
KW
2116 /*
2117 * Open the images.
2118 *
2119 * Ignore the old backing file for unsafe rebase in case we want to correct
2120 * the reference to a renamed or moved backing file.
2121 */
f382d43a 2122 bs = bdrv_new_open(filename, fmt, flags, true, quiet);
c2abccec
MK
2123 if (!bs) {
2124 return 1;
2125 }
3e85c6fd
KW
2126
2127 /* Find the right drivers for the backing files */
2128 old_backing_drv = NULL;
2129 new_backing_drv = NULL;
2130
2131 if (!unsafe && bs->backing_format[0] != '\0') {
2132 old_backing_drv = bdrv_find_format(bs->backing_format);
2133 if (old_backing_drv == NULL) {
15654a6d 2134 error_report("Invalid format name: '%s'", bs->backing_format);
c2abccec
MK
2135 ret = -1;
2136 goto out;
3e85c6fd
KW
2137 }
2138 }
2139
2140 if (out_basefmt != NULL) {
2141 new_backing_drv = bdrv_find_format(out_basefmt);
2142 if (new_backing_drv == NULL) {
15654a6d 2143 error_report("Invalid format name: '%s'", out_basefmt);
c2abccec
MK
2144 ret = -1;
2145 goto out;
3e85c6fd
KW
2146 }
2147 }
2148
2149 /* For safe rebasing we need to compare old and new backing file */
2150 if (unsafe) {
2151 /* Make the compiler happy */
2152 bs_old_backing = NULL;
2153 bs_new_backing = NULL;
2154 } else {
2155 char backing_name[1024];
2156
2157 bs_old_backing = bdrv_new("old_backing");
2158 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
de9c0cec 2159 ret = bdrv_open(bs_old_backing, backing_name, NULL, BDRV_O_FLAGS,
c2abccec
MK
2160 old_backing_drv);
2161 if (ret) {
15654a6d 2162 error_report("Could not open old backing file '%s'", backing_name);
c2abccec 2163 goto out;
3e85c6fd 2164 }
a616673d
AB
2165 if (out_baseimg[0]) {
2166 bs_new_backing = bdrv_new("new_backing");
de9c0cec 2167 ret = bdrv_open(bs_new_backing, out_baseimg, NULL, BDRV_O_FLAGS,
c2abccec 2168 new_backing_drv);
a616673d
AB
2169 if (ret) {
2170 error_report("Could not open new backing file '%s'",
2171 out_baseimg);
2172 goto out;
2173 }
3e85c6fd
KW
2174 }
2175 }
2176
2177 /*
2178 * Check each unallocated cluster in the COW file. If it is unallocated,
2179 * accesses go to the backing file. We must therefore compare this cluster
2180 * in the old and new backing file, and if they differ we need to copy it
2181 * from the old backing file into the COW file.
2182 *
2183 * If qemu-img crashes during this step, no harm is done. The content of
2184 * the image is the same as the original one at any time.
2185 */
2186 if (!unsafe) {
2187 uint64_t num_sectors;
87a1b3e3 2188 uint64_t old_backing_num_sectors;
a616673d 2189 uint64_t new_backing_num_sectors = 0;
3e85c6fd 2190 uint64_t sector;
cc60e327 2191 int n;
d6771bfa
T
2192 uint8_t * buf_old;
2193 uint8_t * buf_new;
1f710495 2194 float local_progress = 0;
d6771bfa 2195
bb1c0597
KW
2196 buf_old = qemu_blockalign(bs, IO_BUF_SIZE);
2197 buf_new = qemu_blockalign(bs, IO_BUF_SIZE);
3e85c6fd
KW
2198
2199 bdrv_get_geometry(bs, &num_sectors);
87a1b3e3 2200 bdrv_get_geometry(bs_old_backing, &old_backing_num_sectors);
a616673d
AB
2201 if (bs_new_backing) {
2202 bdrv_get_geometry(bs_new_backing, &new_backing_num_sectors);
2203 }
3e85c6fd 2204
1f710495
KW
2205 if (num_sectors != 0) {
2206 local_progress = (float)100 /
2207 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
2208 }
2209
3e85c6fd
KW
2210 for (sector = 0; sector < num_sectors; sector += n) {
2211
2212 /* How many sectors can we handle with the next read? */
2213 if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
2214 n = (IO_BUF_SIZE / 512);
2215 } else {
2216 n = num_sectors - sector;
2217 }
2218
2219 /* If the cluster is allocated, we don't need to take action */
cc60e327
KW
2220 ret = bdrv_is_allocated(bs, sector, n, &n);
2221 if (ret) {
3e85c6fd
KW
2222 continue;
2223 }
2224
87a1b3e3
KW
2225 /*
2226 * Read old and new backing file and take into consideration that
2227 * backing files may be smaller than the COW image.
2228 */
2229 if (sector >= old_backing_num_sectors) {
2230 memset(buf_old, 0, n * BDRV_SECTOR_SIZE);
2231 } else {
2232 if (sector + n > old_backing_num_sectors) {
2233 n = old_backing_num_sectors - sector;
2234 }
2235
2236 ret = bdrv_read(bs_old_backing, sector, buf_old, n);
2237 if (ret < 0) {
2238 error_report("error while reading from old backing file");
2239 goto out;
2240 }
3e85c6fd 2241 }
87a1b3e3 2242
a616673d 2243 if (sector >= new_backing_num_sectors || !bs_new_backing) {
87a1b3e3
KW
2244 memset(buf_new, 0, n * BDRV_SECTOR_SIZE);
2245 } else {
2246 if (sector + n > new_backing_num_sectors) {
2247 n = new_backing_num_sectors - sector;
2248 }
2249
2250 ret = bdrv_read(bs_new_backing, sector, buf_new, n);
2251 if (ret < 0) {
2252 error_report("error while reading from new backing file");
2253 goto out;
2254 }
3e85c6fd
KW
2255 }
2256
2257 /* If they differ, we need to write to the COW file */
2258 uint64_t written = 0;
2259
2260 while (written < n) {
2261 int pnum;
2262
2263 if (compare_sectors(buf_old + written * 512,
60b1bd4f 2264 buf_new + written * 512, n - written, &pnum))
3e85c6fd
KW
2265 {
2266 ret = bdrv_write(bs, sector + written,
2267 buf_old + written * 512, pnum);
2268 if (ret < 0) {
15654a6d 2269 error_report("Error while writing to COW image: %s",
3e85c6fd 2270 strerror(-ret));
c2abccec 2271 goto out;
3e85c6fd
KW
2272 }
2273 }
2274
2275 written += pnum;
2276 }
6b837bc4 2277 qemu_progress_print(local_progress, 100);
3e85c6fd 2278 }
d6771bfa 2279
bb1c0597
KW
2280 qemu_vfree(buf_old);
2281 qemu_vfree(buf_new);
3e85c6fd
KW
2282 }
2283
2284 /*
2285 * Change the backing file. All clusters that are different from the old
2286 * backing file are overwritten in the COW file now, so the visible content
2287 * doesn't change when we switch the backing file.
2288 */
a616673d
AB
2289 if (out_baseimg && *out_baseimg) {
2290 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
2291 } else {
2292 ret = bdrv_change_backing_file(bs, NULL, NULL);
2293 }
2294
3e85c6fd 2295 if (ret == -ENOSPC) {
15654a6d
JS
2296 error_report("Could not change the backing file to '%s': No "
2297 "space left in the file header", out_baseimg);
3e85c6fd 2298 } else if (ret < 0) {
15654a6d 2299 error_report("Could not change the backing file to '%s': %s",
3e85c6fd
KW
2300 out_baseimg, strerror(-ret));
2301 }
2302
6b837bc4 2303 qemu_progress_print(100, 0);
3e85c6fd
KW
2304 /*
2305 * TODO At this point it is possible to check if any clusters that are
2306 * allocated in the COW file are the same in the backing file. If so, they
2307 * could be dropped from the COW file. Don't do this before switching the
2308 * backing file, in case of a crash this would lead to corruption.
2309 */
c2abccec 2310out:
6b837bc4 2311 qemu_progress_end();
3e85c6fd
KW
2312 /* Cleanup */
2313 if (!unsafe) {
eb863add
KW
2314 if (bs_old_backing != NULL) {
2315 bdrv_delete(bs_old_backing);
2316 }
2317 if (bs_new_backing != NULL) {
2318 bdrv_delete(bs_new_backing);
2319 }
3e85c6fd
KW
2320 }
2321
2322 bdrv_delete(bs);
c2abccec
MK
2323 if (ret) {
2324 return 1;
2325 }
3e85c6fd
KW
2326 return 0;
2327}
2328
ae6b0ed6
SH
2329static int img_resize(int argc, char **argv)
2330{
2331 int c, ret, relative;
2332 const char *filename, *fmt, *size;
2333 int64_t n, total_size;
f382d43a 2334 bool quiet = false;
2a81998a 2335 BlockDriverState *bs = NULL;
20caf0f7
DXW
2336 QemuOpts *param;
2337 static QemuOptsList resize_options = {
2338 .name = "resize_options",
2339 .head = QTAILQ_HEAD_INITIALIZER(resize_options.head),
2340 .desc = {
2341 {
2342 .name = BLOCK_OPT_SIZE,
2343 .type = QEMU_OPT_SIZE,
2344 .help = "Virtual disk size"
2345 }, {
2346 /* end of list */
2347 }
ae6b0ed6 2348 },
ae6b0ed6
SH
2349 };
2350
e80fec7f
KW
2351 /* Remove size from argv manually so that negative numbers are not treated
2352 * as options by getopt. */
2353 if (argc < 3) {
2354 help();
2355 return 1;
2356 }
2357
2358 size = argv[--argc];
2359
2360 /* Parse getopt arguments */
ae6b0ed6
SH
2361 fmt = NULL;
2362 for(;;) {
f382d43a 2363 c = getopt(argc, argv, "f:hq");
ae6b0ed6
SH
2364 if (c == -1) {
2365 break;
2366 }
2367 switch(c) {
ef87394c 2368 case '?':
ae6b0ed6
SH
2369 case 'h':
2370 help();
2371 break;
2372 case 'f':
2373 fmt = optarg;
2374 break;
f382d43a
MR
2375 case 'q':
2376 quiet = true;
2377 break;
ae6b0ed6
SH
2378 }
2379 }
e80fec7f 2380 if (optind >= argc) {
ae6b0ed6
SH
2381 help();
2382 }
2383 filename = argv[optind++];
ae6b0ed6
SH
2384
2385 /* Choose grow, shrink, or absolute resize mode */
2386 switch (size[0]) {
2387 case '+':
2388 relative = 1;
2389 size++;
2390 break;
2391 case '-':
2392 relative = -1;
2393 size++;
2394 break;
2395 default:
2396 relative = 0;
2397 break;
2398 }
2399
2400 /* Parse size */
e478b448 2401 param = qemu_opts_create_nofail(&resize_options);
20caf0f7 2402 if (qemu_opt_set(param, BLOCK_OPT_SIZE, size)) {
ae6b0ed6 2403 /* Error message already printed when size parsing fails */
2a81998a 2404 ret = -1;
20caf0f7 2405 qemu_opts_del(param);
2a81998a 2406 goto out;
ae6b0ed6 2407 }
20caf0f7
DXW
2408 n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
2409 qemu_opts_del(param);
ae6b0ed6 2410
f382d43a 2411 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR, true, quiet);
c2abccec 2412 if (!bs) {
2a81998a
JS
2413 ret = -1;
2414 goto out;
c2abccec 2415 }
ae6b0ed6
SH
2416
2417 if (relative) {
2418 total_size = bdrv_getlength(bs) + n * relative;
2419 } else {
2420 total_size = n;
2421 }
2422 if (total_size <= 0) {
15654a6d 2423 error_report("New image size must be positive");
c2abccec
MK
2424 ret = -1;
2425 goto out;
ae6b0ed6
SH
2426 }
2427
2428 ret = bdrv_truncate(bs, total_size);
2429 switch (ret) {
2430 case 0:
f382d43a 2431 qprintf(quiet, "Image resized.\n");
ae6b0ed6
SH
2432 break;
2433 case -ENOTSUP:
259b2173 2434 error_report("This image does not support resize");
ae6b0ed6
SH
2435 break;
2436 case -EACCES:
15654a6d 2437 error_report("Image is read-only");
ae6b0ed6
SH
2438 break;
2439 default:
15654a6d 2440 error_report("Error resizing image (%d)", -ret);
ae6b0ed6
SH
2441 break;
2442 }
c2abccec 2443out:
2a81998a
JS
2444 if (bs) {
2445 bdrv_delete(bs);
2446 }
c2abccec
MK
2447 if (ret) {
2448 return 1;
2449 }
ae6b0ed6
SH
2450 return 0;
2451}
2452
c227f099 2453static const img_cmd_t img_cmds[] = {
153859be
SB
2454#define DEF(option, callback, arg_string) \
2455 { option, callback },
2456#include "qemu-img-cmds.h"
2457#undef DEF
2458#undef GEN_DOCS
2459 { NULL, NULL, },
2460};
2461
ea2384d3
FB
2462int main(int argc, char **argv)
2463{
c227f099 2464 const img_cmd_t *cmd;
153859be 2465 const char *cmdname;
ea2384d3 2466
53f76e58
KW
2467 error_set_progname(argv[0]);
2468
2592c59a 2469 qemu_init_main_loop();
ea2384d3
FB
2470 bdrv_init();
2471 if (argc < 2)
2472 help();
153859be 2473 cmdname = argv[1];
8f9b157e 2474 argc--; argv++;
153859be
SB
2475
2476 /* find the command */
2477 for(cmd = img_cmds; cmd->name != NULL; cmd++) {
2478 if (!strcmp(cmdname, cmd->name)) {
2479 return cmd->handler(argc, argv);
2480 }
ea2384d3 2481 }
153859be
SB
2482
2483 /* not found */
2484 help();
ea2384d3
FB
2485 return 0;
2486}