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