blob: fa77ac0dbe87f6fb36d9e6a0b1abd62b752826a7 [file] [log] [blame]
bellardea2384d2004-08-01 21:59:26 +00001/*
bellardfb43f4d2006-08-07 21:34:46 +00002 * QEMU disk image utility
ths5fafdf22007-09-16 21:08:06 +00003 *
bellard68d0f702008-01-06 17:21:48 +00004 * Copyright (c) 2003-2008 Fabrice Bellard
ths5fafdf22007-09-16 21:08:06 +00005 *
bellardea2384d2004-08-01 21:59:26 +00006 * 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 */
pbrookfaf07962007-11-11 02:51:17 +000024#include "qemu-common.h"
Kevin Wolf9ea2ea72009-05-18 16:42:11 +020025#include "qemu-option.h"
aliguorif7b4a942009-01-07 17:40:15 +000026#include "osdep.h"
Jes Sorensendc786bc2010-10-26 10:39:23 +020027#include "sysemu.h"
thsec36ba12007-09-16 21:59:02 +000028#include "block_int.h"
aliguori9230eaf2009-03-28 17:55:19 +000029#include <stdio.h>
bellardea2384d2004-08-01 21:59:26 +000030
bellarde8445332006-06-14 15:32:10 +000031#ifdef _WIN32
32#include <windows.h>
33#endif
34
Anthony Liguoric227f092009-10-01 16:12:16 -050035typedef struct img_cmd_t {
Stuart Brady153859b2009-06-07 00:42:17 +010036 const char *name;
37 int (*handler)(int argc, char **argv);
Anthony Liguoric227f092009-10-01 16:12:16 -050038} img_cmd_t;
Stuart Brady153859b2009-06-07 00:42:17 +010039
aurel32137519c2008-11-30 19:12:49 +000040/* Default to cache=writeback as data integrity is not important for qemu-tcg. */
Stefan Hajnocziadfe0782010-04-13 10:29:35 +010041#define BDRV_O_FLAGS BDRV_O_CACHE_WB
aurel32137519c2008-11-30 19:12:49 +000042
Stefan Weil8b7968f2010-09-23 21:28:05 +020043static void GCC_FMT_ATTR(1, 2) error(const char *fmt, ...)
bellardea2384d2004-08-01 21:59:26 +000044{
45 va_list ap;
46 va_start(ap, fmt);
bellard57d1a2b2004-08-03 21:15:11 +000047 fprintf(stderr, "qemu-img: ");
bellardea2384d2004-08-01 21:59:26 +000048 vfprintf(stderr, fmt, ap);
49 fprintf(stderr, "\n");
bellardea2384d2004-08-01 21:59:26 +000050 va_end(ap);
51}
52
53static void format_print(void *opaque, const char *name)
54{
55 printf(" %s", name);
56}
57
blueswir1d2c639d2009-01-24 18:19:25 +000058/* Please keep in synch with qemu-img.texi */
pbrook3f379ab2007-11-11 03:33:13 +000059static void help(void)
bellardea2384d2004-08-01 21:59:26 +000060{
Paolo Bonzinie00291c2010-02-04 16:49:56 +010061 const char *help_msg =
62 "qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n"
malc3f020d72010-02-08 12:04:56 +030063 "usage: qemu-img command [command options]\n"
64 "QEMU disk image utility\n"
65 "\n"
66 "Command syntax:\n"
Stuart Brady153859b2009-06-07 00:42:17 +010067#define DEF(option, callback, arg_string) \
68 " " arg_string "\n"
69#include "qemu-img-cmds.h"
70#undef DEF
71#undef GEN_DOCS
malc3f020d72010-02-08 12:04:56 +030072 "\n"
73 "Command parameters:\n"
74 " 'filename' is a disk image filename\n"
75 " 'fmt' is the disk image format. It is guessed automatically in most cases\n"
76 " 'size' is the disk image size in bytes. Optional suffixes\n"
77 " 'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n"
78 " and T (terabyte, 1024G) are supported. 'b' is ignored.\n"
79 " 'output_filename' is the destination disk image filename\n"
80 " 'output_fmt' is the destination format\n"
81 " 'options' is a comma separated list of format specific options in a\n"
82 " name=value format. Use -o ? for an overview of the options supported by the\n"
83 " used format\n"
84 " '-c' indicates that target image must be compressed (qcow format only)\n"
85 " '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
86 " match exactly. The image doesn't need a working backing file before\n"
87 " rebasing in this case (useful for renaming the backing file)\n"
88 " '-h' with or without a command shows this help and lists the supported formats\n"
89 "\n"
90 "Parameters to snapshot subcommand:\n"
91 " 'snapshot' is the name of the snapshot to create, apply or delete\n"
92 " '-a' applies a snapshot (revert disk to saved state)\n"
93 " '-c' creates a snapshot\n"
94 " '-d' deletes a snapshot\n"
Paolo Bonzinie00291c2010-02-04 16:49:56 +010095 " '-l' lists all snapshots in the given image\n";
96
97 printf("%s\nSupported formats:", help_msg);
bellardea2384d2004-08-01 21:59:26 +000098 bdrv_iterate_format(format_print, NULL);
99 printf("\n");
100 exit(1);
101}
102
bellardea2384d2004-08-01 21:59:26 +0000103#if defined(WIN32)
104/* XXX: put correct support for win32 */
105static int read_password(char *buf, int buf_size)
106{
107 int c, i;
108 printf("Password: ");
109 fflush(stdout);
110 i = 0;
111 for(;;) {
112 c = getchar();
113 if (c == '\n')
114 break;
115 if (i < (buf_size - 1))
116 buf[i++] = c;
117 }
118 buf[i] = '\0';
119 return 0;
120}
121
122#else
123
124#include <termios.h>
125
126static struct termios oldtty;
127
128static void term_exit(void)
129{
130 tcsetattr (0, TCSANOW, &oldtty);
131}
132
133static void term_init(void)
134{
135 struct termios tty;
136
137 tcgetattr (0, &tty);
138 oldtty = tty;
139
140 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
141 |INLCR|IGNCR|ICRNL|IXON);
142 tty.c_oflag |= OPOST;
143 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
144 tty.c_cflag &= ~(CSIZE|PARENB);
145 tty.c_cflag |= CS8;
146 tty.c_cc[VMIN] = 1;
147 tty.c_cc[VTIME] = 0;
ths3b46e622007-09-17 08:09:54 +0000148
bellardea2384d2004-08-01 21:59:26 +0000149 tcsetattr (0, TCSANOW, &tty);
150
151 atexit(term_exit);
152}
153
pbrook3f379ab2007-11-11 03:33:13 +0000154static int read_password(char *buf, int buf_size)
bellardea2384d2004-08-01 21:59:26 +0000155{
156 uint8_t ch;
157 int i, ret;
158
159 printf("password: ");
160 fflush(stdout);
161 term_init();
162 i = 0;
163 for(;;) {
164 ret = read(0, &ch, 1);
165 if (ret == -1) {
166 if (errno == EAGAIN || errno == EINTR) {
167 continue;
168 } else {
169 ret = -1;
170 break;
171 }
172 } else if (ret == 0) {
173 ret = -1;
174 break;
175 } else {
176 if (ch == '\r') {
177 ret = 0;
178 break;
179 }
180 if (i < (buf_size - 1))
181 buf[i++] = ch;
182 }
183 }
184 term_exit();
185 buf[i] = '\0';
186 printf("\n");
187 return ret;
188}
189#endif
190
bellard75c23802004-08-27 21:28:58 +0000191static BlockDriverState *bdrv_new_open(const char *filename,
Sheng Yang9bc378c2010-01-29 10:15:06 +0800192 const char *fmt,
Stefan Hajnoczif163d072010-04-13 10:29:34 +0100193 int flags)
bellard75c23802004-08-27 21:28:58 +0000194{
195 BlockDriverState *bs;
196 BlockDriver *drv;
197 char password[256];
198
199 bs = bdrv_new("");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900200 if (!bs) {
bellard75c23802004-08-27 21:28:58 +0000201 error("Not enough memory");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900202 goto fail;
203 }
bellard75c23802004-08-27 21:28:58 +0000204 if (fmt) {
205 drv = bdrv_find_format(fmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900206 if (!drv) {
bellard75c23802004-08-27 21:28:58 +0000207 error("Unknown file format '%s'", fmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900208 goto fail;
209 }
bellard75c23802004-08-27 21:28:58 +0000210 } else {
211 drv = NULL;
212 }
Kevin Wolfd6e90982010-03-31 14:40:27 +0200213 if (bdrv_open(bs, filename, flags, drv) < 0) {
bellard75c23802004-08-27 21:28:58 +0000214 error("Could not open '%s'", filename);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900215 goto fail;
bellard75c23802004-08-27 21:28:58 +0000216 }
217 if (bdrv_is_encrypted(bs)) {
218 printf("Disk image '%s' is encrypted.\n", filename);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900219 if (read_password(password, sizeof(password)) < 0) {
bellard75c23802004-08-27 21:28:58 +0000220 error("No password given");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900221 goto fail;
222 }
223 if (bdrv_set_key(bs, password) < 0) {
bellard75c23802004-08-27 21:28:58 +0000224 error("invalid password");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900225 goto fail;
226 }
bellard75c23802004-08-27 21:28:58 +0000227 }
228 return bs;
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900229fail:
230 if (bs) {
231 bdrv_delete(bs);
232 }
233 return NULL;
bellard75c23802004-08-27 21:28:58 +0000234}
235
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900236static int add_old_style_options(const char *fmt, QEMUOptionParameter *list,
Kevin Wolfefa84d42009-05-18 16:42:12 +0200237 int flags, const char *base_filename, const char *base_fmt)
238{
239 if (flags & BLOCK_FLAG_ENCRYPT) {
240 if (set_option_parameter(list, BLOCK_OPT_ENCRYPT, "on")) {
241 error("Encryption not supported for file format '%s'", fmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900242 return -1;
Kevin Wolfefa84d42009-05-18 16:42:12 +0200243 }
244 }
245 if (flags & BLOCK_FLAG_COMPAT6) {
246 if (set_option_parameter(list, BLOCK_OPT_COMPAT6, "on")) {
247 error("VMDK version 6 not supported for file format '%s'", fmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900248 return -1;
Kevin Wolfefa84d42009-05-18 16:42:12 +0200249 }
250 }
251
252 if (base_filename) {
253 if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) {
254 error("Backing file not supported for file format '%s'", fmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900255 return -1;
Kevin Wolfefa84d42009-05-18 16:42:12 +0200256 }
257 }
258 if (base_fmt) {
259 if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) {
260 error("Backing file format not supported for file format '%s'", fmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900261 return -1;
Kevin Wolfefa84d42009-05-18 16:42:12 +0200262 }
263 }
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900264 return 0;
Kevin Wolfefa84d42009-05-18 16:42:12 +0200265}
266
bellardea2384d2004-08-01 21:59:26 +0000267static int img_create(int argc, char **argv)
268{
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900269 int c, ret = 0, flags;
bellardea2384d2004-08-01 21:59:26 +0000270 const char *fmt = "raw";
aliguori9230eaf2009-03-28 17:55:19 +0000271 const char *base_fmt = NULL;
bellardea2384d2004-08-01 21:59:26 +0000272 const char *filename;
273 const char *base_filename = NULL;
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900274 BlockDriver *drv, *proto_drv;
275 QEMUOptionParameter *param = NULL, *create_options = NULL;
Kevin Wolf9ea2ea72009-05-18 16:42:11 +0200276 char *options = NULL;
ths3b46e622007-09-17 08:09:54 +0000277
thsec36ba12007-09-16 21:59:02 +0000278 flags = 0;
bellardea2384d2004-08-01 21:59:26 +0000279 for(;;) {
Kevin Wolf9ea2ea72009-05-18 16:42:11 +0200280 c = getopt(argc, argv, "F:b:f:he6o:");
bellardea2384d2004-08-01 21:59:26 +0000281 if (c == -1)
282 break;
283 switch(c) {
284 case 'h':
285 help();
286 break;
aliguori9230eaf2009-03-28 17:55:19 +0000287 case 'F':
288 base_fmt = optarg;
289 break;
bellardea2384d2004-08-01 21:59:26 +0000290 case 'b':
291 base_filename = optarg;
292 break;
293 case 'f':
294 fmt = optarg;
295 break;
296 case 'e':
thsec36ba12007-09-16 21:59:02 +0000297 flags |= BLOCK_FLAG_ENCRYPT;
bellardea2384d2004-08-01 21:59:26 +0000298 break;
thsd8871c52007-10-24 16:11:42 +0000299 case '6':
thsec36ba12007-09-16 21:59:02 +0000300 flags |= BLOCK_FLAG_COMPAT6;
thsd8871c52007-10-24 16:11:42 +0000301 break;
Kevin Wolf9ea2ea72009-05-18 16:42:11 +0200302 case 'o':
303 options = optarg;
304 break;
bellardea2384d2004-08-01 21:59:26 +0000305 }
306 }
aliguori9230eaf2009-03-28 17:55:19 +0000307
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900308 /* Get the filename */
309 if (optind >= argc)
310 help();
311 filename = argv[optind++];
312
Kevin Wolf9ea2ea72009-05-18 16:42:11 +0200313 /* Find driver and parse its options */
bellardea2384d2004-08-01 21:59:26 +0000314 drv = bdrv_find_format(fmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900315 if (!drv) {
bellardea2384d2004-08-01 21:59:26 +0000316 error("Unknown file format '%s'", fmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900317 return 1;
318 }
Kevin Wolf9ea2ea72009-05-18 16:42:11 +0200319
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900320 proto_drv = bdrv_find_protocol(filename);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900321 if (!proto_drv) {
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900322 error("Unknown protocol '%s'", filename);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900323 return 1;
324 }
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900325
326 create_options = append_option_parameters(create_options,
327 drv->create_options);
328 create_options = append_option_parameters(create_options,
329 proto_drv->create_options);
330
Kevin Wolfdb08adf2009-06-04 15:39:38 +0200331 if (options && !strcmp(options, "?")) {
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900332 print_option_help(create_options);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900333 goto out;
Kevin Wolfdb08adf2009-06-04 15:39:38 +0200334 }
335
Kevin Wolf9f566402009-10-28 11:36:07 +0100336 /* Create parameter list with default values */
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900337 param = parse_option_parameters("", create_options, param);
Kevin Wolf9f566402009-10-28 11:36:07 +0100338 set_option_parameter_int(param, BLOCK_OPT_SIZE, -1);
339
340 /* Parse -o options */
Kevin Wolf9ea2ea72009-05-18 16:42:11 +0200341 if (options) {
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900342 param = parse_option_parameters(options, create_options, param);
Kevin Wolf9ea2ea72009-05-18 16:42:11 +0200343 if (param == NULL) {
344 error("Invalid options for file format '%s'.", fmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900345 ret = -1;
346 goto out;
Kevin Wolf9ea2ea72009-05-18 16:42:11 +0200347 }
bellard75c23802004-08-27 21:28:58 +0000348 }
Kevin Wolf9ea2ea72009-05-18 16:42:11 +0200349
350 /* Add size to parameters */
351 if (optind < argc) {
352 set_option_parameter(param, BLOCK_OPT_SIZE, argv[optind++]);
353 }
354
355 /* Add old-style options to parameters */
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900356 ret = add_old_style_options(fmt, param, flags, base_filename, base_fmt);
357 if (ret < 0) {
358 goto out;
359 }
Kevin Wolf9ea2ea72009-05-18 16:42:11 +0200360
361 // The size for the image must always be specified, with one exception:
362 // If we are using a backing file, we can obtain the size from there
Kevin Wolf9f566402009-10-28 11:36:07 +0100363 if (get_option_parameter(param, BLOCK_OPT_SIZE)->value.n == -1) {
Kevin Wolf9ea2ea72009-05-18 16:42:11 +0200364
365 QEMUOptionParameter *backing_file =
366 get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
367 QEMUOptionParameter *backing_fmt =
368 get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
369
370 if (backing_file && backing_file->value.s) {
371 BlockDriverState *bs;
372 uint64_t size;
373 const char *fmt = NULL;
374 char buf[32];
375
376 if (backing_fmt && backing_fmt->value.s) {
377 if (bdrv_find_format(backing_fmt->value.s)) {
378 fmt = backing_fmt->value.s;
379 } else {
380 error("Unknown backing file format '%s'",
381 backing_fmt->value.s);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900382 ret = -1;
383 goto out;
Kevin Wolf9ea2ea72009-05-18 16:42:11 +0200384 }
385 }
386
Stefan Hajnocziadfe0782010-04-13 10:29:35 +0100387 bs = bdrv_new_open(backing_file->value.s, fmt, BDRV_O_FLAGS);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900388 if (!bs) {
389 ret = -1;
390 goto out;
391 }
Kevin Wolf9ea2ea72009-05-18 16:42:11 +0200392 bdrv_get_geometry(bs, &size);
393 size *= 512;
394 bdrv_delete(bs);
395
396 snprintf(buf, sizeof(buf), "%" PRId64, size);
397 set_option_parameter(param, BLOCK_OPT_SIZE, buf);
398 } else {
399 error("Image creation needs a size parameter");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900400 ret = -1;
401 goto out;
Kevin Wolf9ea2ea72009-05-18 16:42:11 +0200402 }
403 }
404
405 printf("Formatting '%s', fmt=%s ", filename, fmt);
406 print_option_parameters(param);
407 puts("");
408
409 ret = bdrv_create(drv, filename, param);
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900410 free_option_parameters(create_options);
Kevin Wolf9ea2ea72009-05-18 16:42:11 +0200411 free_option_parameters(param);
412
bellardea2384d2004-08-01 21:59:26 +0000413 if (ret < 0) {
414 if (ret == -ENOTSUP) {
bellard3c565212004-09-29 21:29:14 +0000415 error("Formatting or formatting option not supported for file format '%s'", fmt);
aurel326e9ea0c2009-04-15 14:42:46 +0000416 } else if (ret == -EFBIG) {
417 error("The image size is too large for file format '%s'", fmt);
bellardea2384d2004-08-01 21:59:26 +0000418 } else {
Juan Quintela3e7896d2010-03-04 10:00:38 +0100419 error("%s: error while creating %s: %s", filename, fmt, strerror(-ret));
bellardea2384d2004-08-01 21:59:26 +0000420 }
421 }
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900422out:
423 if (ret) {
424 return 1;
425 }
bellardea2384d2004-08-01 21:59:26 +0000426 return 0;
427}
428
Kevin Wolfe076f332010-06-29 11:43:13 +0200429/*
430 * Checks an image for consistency. Exit codes:
431 *
432 * 0 - Check completed, image is good
433 * 1 - Check not completed because of internal errors
434 * 2 - Check completed, image is corrupted
435 * 3 - Check completed, image has leaked clusters, but is good otherwise
436 */
aliguori15859692009-04-21 23:11:53 +0000437static int img_check(int argc, char **argv)
438{
439 int c, ret;
440 const char *filename, *fmt;
aliguori15859692009-04-21 23:11:53 +0000441 BlockDriverState *bs;
Kevin Wolfe076f332010-06-29 11:43:13 +0200442 BdrvCheckResult result;
aliguori15859692009-04-21 23:11:53 +0000443
444 fmt = NULL;
445 for(;;) {
446 c = getopt(argc, argv, "f:h");
447 if (c == -1)
448 break;
449 switch(c) {
450 case 'h':
451 help();
452 break;
453 case 'f':
454 fmt = optarg;
455 break;
456 }
457 }
458 if (optind >= argc)
459 help();
460 filename = argv[optind++];
461
Stefan Hajnocziadfe0782010-04-13 10:29:35 +0100462 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900463 if (!bs) {
464 return 1;
465 }
Kevin Wolfe076f332010-06-29 11:43:13 +0200466 ret = bdrv_check(bs, &result);
467
468 if (ret == -ENOTSUP) {
aliguori15859692009-04-21 23:11:53 +0000469 error("This image format does not support checks");
Kevin Wolfe076f332010-06-29 11:43:13 +0200470 bdrv_delete(bs);
471 return 1;
472 }
473
474 if (!(result.corruptions || result.leaks || result.check_errors)) {
475 printf("No errors were found on the image.\n");
476 } else {
477 if (result.corruptions) {
478 printf("\n%d errors were found on the image.\n"
479 "Data may be corrupted, or further writes to the image "
480 "may corrupt it.\n",
481 result.corruptions);
aliguori15859692009-04-21 23:11:53 +0000482 }
Kevin Wolfe076f332010-06-29 11:43:13 +0200483
484 if (result.leaks) {
485 printf("\n%d leaked clusters were found on the image.\n"
486 "This means waste of disk space, but no harm to data.\n",
487 result.leaks);
488 }
489
490 if (result.check_errors) {
491 printf("\n%d internal errors have occurred during the check.\n",
492 result.check_errors);
493 }
aliguori15859692009-04-21 23:11:53 +0000494 }
495
496 bdrv_delete(bs);
Kevin Wolfe076f332010-06-29 11:43:13 +0200497
498 if (ret < 0 || result.check_errors) {
499 printf("\nAn error has occurred during the check: %s\n"
500 "The check is not complete and may have missed error.\n",
501 strerror(-ret));
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900502 return 1;
503 }
Kevin Wolfe076f332010-06-29 11:43:13 +0200504
505 if (result.corruptions) {
506 return 2;
507 } else if (result.leaks) {
508 return 3;
509 } else {
510 return 0;
511 }
aliguori15859692009-04-21 23:11:53 +0000512}
513
bellardea2384d2004-08-01 21:59:26 +0000514static int img_commit(int argc, char **argv)
515{
516 int c, ret;
517 const char *filename, *fmt;
bellardea2384d2004-08-01 21:59:26 +0000518 BlockDriverState *bs;
519
520 fmt = NULL;
521 for(;;) {
522 c = getopt(argc, argv, "f:h");
523 if (c == -1)
524 break;
525 switch(c) {
526 case 'h':
527 help();
528 break;
529 case 'f':
530 fmt = optarg;
531 break;
532 }
533 }
ths5fafdf22007-09-16 21:08:06 +0000534 if (optind >= argc)
bellardea2384d2004-08-01 21:59:26 +0000535 help();
536 filename = argv[optind++];
537
Stefan Hajnocziadfe0782010-04-13 10:29:35 +0100538 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900539 if (!bs) {
540 return 1;
541 }
bellardea2384d2004-08-01 21:59:26 +0000542 ret = bdrv_commit(bs);
543 switch(ret) {
544 case 0:
545 printf("Image committed.\n");
546 break;
547 case -ENOENT:
548 error("No disk inserted");
549 break;
550 case -EACCES:
551 error("Image is read-only");
552 break;
553 case -ENOTSUP:
554 error("Image is already committed");
555 break;
556 default:
557 error("Error while committing image");
558 break;
559 }
560
561 bdrv_delete(bs);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900562 if (ret) {
563 return 1;
564 }
bellardea2384d2004-08-01 21:59:26 +0000565 return 0;
566}
567
568static int is_not_zero(const uint8_t *sector, int len)
569{
570 int i;
571 len >>= 2;
572 for(i = 0;i < len; i++) {
573 if (((uint32_t *)sector)[i] != 0)
574 return 1;
575 }
576 return 0;
577}
578
thsf58c7b32008-06-05 21:53:49 +0000579/*
580 * Returns true iff the first sector pointed to by 'buf' contains at least
581 * a non-NUL byte.
582 *
583 * 'pnum' is set to the number of sectors (including and immediately following
584 * the first one) that are known to be in the same allocated/unallocated state.
585 */
bellardea2384d2004-08-01 21:59:26 +0000586static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
587{
588 int v, i;
589
590 if (n <= 0) {
591 *pnum = 0;
592 return 0;
593 }
594 v = is_not_zero(buf, 512);
595 for(i = 1; i < n; i++) {
596 buf += 512;
597 if (v != is_not_zero(buf, 512))
598 break;
599 }
600 *pnum = i;
601 return v;
602}
603
Kevin Wolf3e85c6f2010-01-12 12:55:18 +0100604/*
605 * Compares two buffers sector by sector. Returns 0 if the first sector of both
606 * buffers matches, non-zero otherwise.
607 *
608 * pnum is set to the number of sectors (including and immediately following
609 * the first one) that are known to have the same comparison result
610 */
611static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
612 int *pnum)
613{
614 int res, i;
615
616 if (n <= 0) {
617 *pnum = 0;
618 return 0;
619 }
620
621 res = !!memcmp(buf1, buf2, 512);
622 for(i = 1; i < n; i++) {
623 buf1 += 512;
624 buf2 += 512;
625
626 if (!!memcmp(buf1, buf2, 512) != res) {
627 break;
628 }
629 }
630
631 *pnum = i;
632 return res;
633}
634
Kevin Wolf80ee15a2009-09-15 12:30:43 +0200635#define IO_BUF_SIZE (2 * 1024 * 1024)
bellardea2384d2004-08-01 21:59:26 +0000636
637static int img_convert(int argc, char **argv)
638{
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900639 int c, ret = 0, n, n1, bs_n, bs_i, flags, cluster_size, cluster_sectors;
thsf58c7b32008-06-05 21:53:49 +0000640 const char *fmt, *out_fmt, *out_baseimg, *out_filename;
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900641 BlockDriver *drv, *proto_drv;
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900642 BlockDriverState **bs = NULL, *out_bs = NULL;
ths96b8f132007-12-17 01:35:20 +0000643 int64_t total_sectors, nb_sectors, sector_num, bs_offset;
644 uint64_t bs_sectors;
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900645 uint8_t * buf = NULL;
bellardea2384d2004-08-01 21:59:26 +0000646 const uint8_t *buf1;
bellardfaea38e2006-08-05 21:31:00 +0000647 BlockDriverInfo bdi;
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900648 QEMUOptionParameter *param = NULL, *create_options = NULL;
Kevin Wolfa18953f2010-10-14 15:46:04 +0200649 QEMUOptionParameter *out_baseimg_param;
Kevin Wolfefa84d42009-05-18 16:42:12 +0200650 char *options = NULL;
edison51ef6722010-09-21 19:58:41 -0700651 const char *snapshot_name = NULL;
bellardea2384d2004-08-01 21:59:26 +0000652
653 fmt = NULL;
654 out_fmt = "raw";
thsf58c7b32008-06-05 21:53:49 +0000655 out_baseimg = NULL;
thsec36ba12007-09-16 21:59:02 +0000656 flags = 0;
bellardea2384d2004-08-01 21:59:26 +0000657 for(;;) {
edison51ef6722010-09-21 19:58:41 -0700658 c = getopt(argc, argv, "f:O:B:s:hce6o:");
bellardea2384d2004-08-01 21:59:26 +0000659 if (c == -1)
660 break;
661 switch(c) {
662 case 'h':
663 help();
664 break;
665 case 'f':
666 fmt = optarg;
667 break;
668 case 'O':
669 out_fmt = optarg;
670 break;
thsf58c7b32008-06-05 21:53:49 +0000671 case 'B':
672 out_baseimg = optarg;
673 break;
bellardea2384d2004-08-01 21:59:26 +0000674 case 'c':
thsec36ba12007-09-16 21:59:02 +0000675 flags |= BLOCK_FLAG_COMPRESS;
bellardea2384d2004-08-01 21:59:26 +0000676 break;
677 case 'e':
thsec36ba12007-09-16 21:59:02 +0000678 flags |= BLOCK_FLAG_ENCRYPT;
679 break;
680 case '6':
681 flags |= BLOCK_FLAG_COMPAT6;
bellardea2384d2004-08-01 21:59:26 +0000682 break;
Kevin Wolfefa84d42009-05-18 16:42:12 +0200683 case 'o':
684 options = optarg;
685 break;
edison51ef6722010-09-21 19:58:41 -0700686 case 's':
687 snapshot_name = optarg;
688 break;
bellardea2384d2004-08-01 21:59:26 +0000689 }
690 }
ths3b46e622007-09-17 08:09:54 +0000691
balrog926c2d22007-10-31 01:11:44 +0000692 bs_n = argc - optind - 1;
693 if (bs_n < 1) help();
694
695 out_filename = argv[argc - 1];
thsf58c7b32008-06-05 21:53:49 +0000696
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900697 if (bs_n > 1 && out_baseimg) {
thsf58c7b32008-06-05 21:53:49 +0000698 error("-B makes no sense when concatenating multiple input images");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900699 return 1;
700 }
balrog926c2d22007-10-31 01:11:44 +0000701
702 bs = calloc(bs_n, sizeof(BlockDriverState *));
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900703 if (!bs) {
balrog926c2d22007-10-31 01:11:44 +0000704 error("Out of memory");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900705 return 1;
706 }
balrog926c2d22007-10-31 01:11:44 +0000707
708 total_sectors = 0;
709 for (bs_i = 0; bs_i < bs_n; bs_i++) {
Stefan Hajnocziadfe0782010-04-13 10:29:35 +0100710 bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, BDRV_O_FLAGS);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900711 if (!bs[bs_i]) {
balrog926c2d22007-10-31 01:11:44 +0000712 error("Could not open '%s'", argv[optind + bs_i]);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900713 ret = -1;
714 goto out;
715 }
balrog926c2d22007-10-31 01:11:44 +0000716 bdrv_get_geometry(bs[bs_i], &bs_sectors);
717 total_sectors += bs_sectors;
718 }
bellardea2384d2004-08-01 21:59:26 +0000719
edison51ef6722010-09-21 19:58:41 -0700720 if (snapshot_name != NULL) {
721 if (bs_n > 1) {
722 error("No support for concatenating multiple snapshot\n");
723 ret = -1;
724 goto out;
725 }
726 if (bdrv_snapshot_load_tmp(bs[0], snapshot_name) < 0) {
727 error("Failed to load snapshot\n");
728 ret = -1;
729 goto out;
730 }
731 }
732
Kevin Wolfefa84d42009-05-18 16:42:12 +0200733 /* Find driver and parse its options */
bellardea2384d2004-08-01 21:59:26 +0000734 drv = bdrv_find_format(out_fmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900735 if (!drv) {
thsd34dda52007-02-10 22:59:40 +0000736 error("Unknown file format '%s'", out_fmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900737 ret = -1;
738 goto out;
739 }
balrog926c2d22007-10-31 01:11:44 +0000740
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900741 proto_drv = bdrv_find_protocol(out_filename);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900742 if (!proto_drv) {
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900743 error("Unknown protocol '%s'", out_filename);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900744 ret = -1;
745 goto out;
746 }
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900747
748 create_options = append_option_parameters(create_options,
749 drv->create_options);
750 create_options = append_option_parameters(create_options,
751 proto_drv->create_options);
Kevin Wolfdb08adf2009-06-04 15:39:38 +0200752 if (options && !strcmp(options, "?")) {
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900753 print_option_help(create_options);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900754 goto out;
Kevin Wolfdb08adf2009-06-04 15:39:38 +0200755 }
756
Kevin Wolfefa84d42009-05-18 16:42:12 +0200757 if (options) {
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900758 param = parse_option_parameters(options, create_options, param);
Kevin Wolfefa84d42009-05-18 16:42:12 +0200759 if (param == NULL) {
760 error("Invalid options for file format '%s'.", out_fmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900761 ret = -1;
762 goto out;
Kevin Wolfefa84d42009-05-18 16:42:12 +0200763 }
764 } else {
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900765 param = parse_option_parameters("", create_options, param);
Kevin Wolfefa84d42009-05-18 16:42:12 +0200766 }
767
768 set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900769 ret = add_old_style_options(out_fmt, param, flags, out_baseimg, NULL);
770 if (ret < 0) {
771 goto out;
772 }
Kevin Wolfefa84d42009-05-18 16:42:12 +0200773
Kevin Wolfa18953f2010-10-14 15:46:04 +0200774 /* Get backing file name if -o backing_file was used */
775 out_baseimg_param = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
776 if (out_baseimg_param) {
777 out_baseimg = out_baseimg_param->value.s;
778 }
779
Kevin Wolfefa84d42009-05-18 16:42:12 +0200780 /* Check if compression is supported */
781 if (flags & BLOCK_FLAG_COMPRESS) {
782 QEMUOptionParameter *encryption =
783 get_option_parameter(param, BLOCK_OPT_ENCRYPT);
784
785 if (!drv->bdrv_write_compressed) {
786 error("Compression not supported for this file format");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900787 ret = -1;
788 goto out;
Kevin Wolfefa84d42009-05-18 16:42:12 +0200789 }
790
791 if (encryption && encryption->value.n) {
792 error("Compression and encryption not supported at the same time");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900793 ret = -1;
794 goto out;
Kevin Wolfefa84d42009-05-18 16:42:12 +0200795 }
796 }
797
798 /* Create the new image */
799 ret = bdrv_create(drv, out_filename, param);
bellardea2384d2004-08-01 21:59:26 +0000800 if (ret < 0) {
801 if (ret == -ENOTSUP) {
aliguori93c65b42009-04-05 17:40:43 +0000802 error("Formatting not supported for file format '%s'", out_fmt);
aurel326e9ea0c2009-04-15 14:42:46 +0000803 } else if (ret == -EFBIG) {
804 error("The image size is too large for file format '%s'", out_fmt);
bellardea2384d2004-08-01 21:59:26 +0000805 } else {
Juan Quintela3e7896d2010-03-04 10:00:38 +0100806 error("%s: error while converting %s: %s", out_filename, out_fmt, strerror(-ret));
bellardea2384d2004-08-01 21:59:26 +0000807 }
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900808 goto out;
bellardea2384d2004-08-01 21:59:26 +0000809 }
ths3b46e622007-09-17 08:09:54 +0000810
Kevin Wolf1bd8e172010-08-31 13:44:25 +0200811 out_bs = bdrv_new_open(out_filename, out_fmt,
812 BDRV_O_FLAGS | BDRV_O_RDWR | BDRV_O_NO_FLUSH);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900813 if (!out_bs) {
814 ret = -1;
815 goto out;
816 }
bellardea2384d2004-08-01 21:59:26 +0000817
balrog926c2d22007-10-31 01:11:44 +0000818 bs_i = 0;
819 bs_offset = 0;
820 bdrv_get_geometry(bs[0], &bs_sectors);
TeLeMand6771bf2010-02-08 16:20:00 +0800821 buf = qemu_malloc(IO_BUF_SIZE);
balrog926c2d22007-10-31 01:11:44 +0000822
823 if (flags & BLOCK_FLAG_COMPRESS) {
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900824 ret = bdrv_get_info(out_bs, &bdi);
825 if (ret < 0) {
bellardfaea38e2006-08-05 21:31:00 +0000826 error("could not get block driver info");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900827 goto out;
828 }
bellardfaea38e2006-08-05 21:31:00 +0000829 cluster_size = bdi.cluster_size;
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900830 if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) {
bellardea2384d2004-08-01 21:59:26 +0000831 error("invalid cluster size");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900832 ret = -1;
833 goto out;
834 }
bellardea2384d2004-08-01 21:59:26 +0000835 cluster_sectors = cluster_size >> 9;
836 sector_num = 0;
837 for(;;) {
balrog926c2d22007-10-31 01:11:44 +0000838 int64_t bs_num;
839 int remainder;
840 uint8_t *buf2;
841
bellardea2384d2004-08-01 21:59:26 +0000842 nb_sectors = total_sectors - sector_num;
843 if (nb_sectors <= 0)
844 break;
845 if (nb_sectors >= cluster_sectors)
846 n = cluster_sectors;
847 else
848 n = nb_sectors;
balrog926c2d22007-10-31 01:11:44 +0000849
850 bs_num = sector_num - bs_offset;
851 assert (bs_num >= 0);
852 remainder = n;
853 buf2 = buf;
854 while (remainder > 0) {
855 int nlow;
856 while (bs_num == bs_sectors) {
857 bs_i++;
858 assert (bs_i < bs_n);
859 bs_offset += bs_sectors;
860 bdrv_get_geometry(bs[bs_i], &bs_sectors);
861 bs_num = 0;
Blue Swirl0bfcd592010-05-22 08:02:12 +0000862 /* printf("changing part: sector_num=%" PRId64 ", "
863 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
864 "\n", sector_num, bs_i, bs_offset, bs_sectors); */
balrog926c2d22007-10-31 01:11:44 +0000865 }
866 assert (bs_num < bs_sectors);
867
868 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;
869
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900870 ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow);
871 if (ret < 0) {
balrog926c2d22007-10-31 01:11:44 +0000872 error("error while reading");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900873 goto out;
874 }
balrog926c2d22007-10-31 01:11:44 +0000875
876 buf2 += nlow * 512;
877 bs_num += nlow;
878
879 remainder -= nlow;
880 }
881 assert (remainder == 0);
882
bellardea2384d2004-08-01 21:59:26 +0000883 if (n < cluster_sectors)
884 memset(buf + n * 512, 0, cluster_size - n * 512);
885 if (is_not_zero(buf, cluster_size)) {
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900886 ret = bdrv_write_compressed(out_bs, sector_num, buf,
887 cluster_sectors);
888 if (ret != 0) {
bellardec3757d2006-06-14 15:50:07 +0000889 error("error while compressing sector %" PRId64,
890 sector_num);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900891 goto out;
892 }
bellardea2384d2004-08-01 21:59:26 +0000893 }
894 sector_num += n;
895 }
bellardfaea38e2006-08-05 21:31:00 +0000896 /* signal EOF to align */
897 bdrv_write_compressed(out_bs, 0, NULL, 0);
bellardea2384d2004-08-01 21:59:26 +0000898 } else {
Kevin Wolff2feebb2010-04-14 17:30:35 +0200899 int has_zero_init = bdrv_has_zero_init(out_bs);
900
thsf58c7b32008-06-05 21:53:49 +0000901 sector_num = 0; // total number of sectors converted so far
bellardea2384d2004-08-01 21:59:26 +0000902 for(;;) {
903 nb_sectors = total_sectors - sector_num;
904 if (nb_sectors <= 0)
905 break;
906 if (nb_sectors >= (IO_BUF_SIZE / 512))
907 n = (IO_BUF_SIZE / 512);
908 else
909 n = nb_sectors;
balrog926c2d22007-10-31 01:11:44 +0000910
911 while (sector_num - bs_offset >= bs_sectors) {
912 bs_i ++;
913 assert (bs_i < bs_n);
914 bs_offset += bs_sectors;
915 bdrv_get_geometry(bs[bs_i], &bs_sectors);
Blue Swirl0bfcd592010-05-22 08:02:12 +0000916 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
917 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
balrog926c2d22007-10-31 01:11:44 +0000918 sector_num, bs_i, bs_offset, bs_sectors); */
919 }
920
921 if (n > bs_offset + bs_sectors - sector_num)
922 n = bs_offset + bs_sectors - sector_num;
923
Kevin Wolff2feebb2010-04-14 17:30:35 +0200924 if (has_zero_init) {
Akkarit Sangpetchd0320442009-07-17 10:02:15 +0200925 /* If the output image is being created as a copy on write image,
926 assume that sectors which are unallocated in the input image
927 are present in both the output's and input's base images (no
928 need to copy them). */
929 if (out_baseimg) {
930 if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
931 n, &n1)) {
932 sector_num += n1;
933 continue;
934 }
935 /* The next 'n1' sectors are allocated in the input image. Copy
936 only those as they may be followed by unallocated sectors. */
937 n = n1;
aliguori93c65b42009-04-05 17:40:43 +0000938 }
aliguori93c65b42009-04-05 17:40:43 +0000939 } else {
940 n1 = n;
thsf58c7b32008-06-05 21:53:49 +0000941 }
942
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900943 ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
944 if (ret < 0) {
bellardea2384d2004-08-01 21:59:26 +0000945 error("error while reading");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900946 goto out;
947 }
bellardea2384d2004-08-01 21:59:26 +0000948 /* NOTE: at the same time we convert, we do not write zero
949 sectors to have a chance to compress the image. Ideally, we
950 should add a specific call to have the info to go faster */
951 buf1 = buf;
952 while (n > 0) {
thsf58c7b32008-06-05 21:53:49 +0000953 /* If the output image is being created as a copy on write image,
954 copy all sectors even the ones containing only NUL bytes,
aliguori93c65b42009-04-05 17:40:43 +0000955 because they may differ from the sectors in the base image.
956
957 If the output is to a host device, we also write out
958 sectors that are entirely 0, since whatever data was
959 already there is garbage, not 0s. */
Kevin Wolff2feebb2010-04-14 17:30:35 +0200960 if (!has_zero_init || out_baseimg ||
aliguori93c65b42009-04-05 17:40:43 +0000961 is_allocated_sectors(buf1, n, &n1)) {
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900962 ret = bdrv_write(out_bs, sector_num, buf1, n1);
963 if (ret < 0) {
bellardea2384d2004-08-01 21:59:26 +0000964 error("error while writing");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900965 goto out;
966 }
bellardea2384d2004-08-01 21:59:26 +0000967 }
968 sector_num += n1;
969 n -= n1;
970 buf1 += n1 * 512;
971 }
972 }
973 }
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900974out:
975 free_option_parameters(create_options);
976 free_option_parameters(param);
TeLeMand6771bf2010-02-08 16:20:00 +0800977 qemu_free(buf);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900978 if (out_bs) {
979 bdrv_delete(out_bs);
980 }
981 for (bs_i = 0; bs_i < bs_n; bs_i++) {
982 if (bs[bs_i]) {
983 bdrv_delete(bs[bs_i]);
984 }
985 }
balrog926c2d22007-10-31 01:11:44 +0000986 free(bs);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900987 if (ret) {
988 return 1;
989 }
bellardea2384d2004-08-01 21:59:26 +0000990 return 0;
991}
992
bellard57d1a2b2004-08-03 21:15:11 +0000993#ifdef _WIN32
994static int64_t get_allocated_file_size(const char *filename)
995{
bellarde8445332006-06-14 15:32:10 +0000996 typedef DWORD (WINAPI * get_compressed_t)(const char *filename, DWORD *high);
997 get_compressed_t get_compressed;
bellard57d1a2b2004-08-03 21:15:11 +0000998 struct _stati64 st;
bellarde8445332006-06-14 15:32:10 +0000999
1000 /* WinNT support GetCompressedFileSize to determine allocate size */
1001 get_compressed = (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA");
1002 if (get_compressed) {
1003 DWORD high, low;
1004 low = get_compressed(filename, &high);
1005 if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR)
1006 return (((int64_t) high) << 32) + low;
1007 }
1008
ths5fafdf22007-09-16 21:08:06 +00001009 if (_stati64(filename, &st) < 0)
bellard57d1a2b2004-08-03 21:15:11 +00001010 return -1;
1011 return st.st_size;
1012}
1013#else
1014static int64_t get_allocated_file_size(const char *filename)
1015{
1016 struct stat st;
ths5fafdf22007-09-16 21:08:06 +00001017 if (stat(filename, &st) < 0)
bellard57d1a2b2004-08-03 21:15:11 +00001018 return -1;
1019 return (int64_t)st.st_blocks * 512;
1020}
1021#endif
1022
bellardfaea38e2006-08-05 21:31:00 +00001023static void dump_snapshots(BlockDriverState *bs)
1024{
1025 QEMUSnapshotInfo *sn_tab, *sn;
1026 int nb_sns, i;
1027 char buf[256];
1028
1029 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1030 if (nb_sns <= 0)
1031 return;
1032 printf("Snapshot list:\n");
1033 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
1034 for(i = 0; i < nb_sns; i++) {
1035 sn = &sn_tab[i];
1036 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
1037 }
1038 qemu_free(sn_tab);
1039}
1040
bellardea2384d2004-08-01 21:59:26 +00001041static int img_info(int argc, char **argv)
1042{
1043 int c;
1044 const char *filename, *fmt;
bellardea2384d2004-08-01 21:59:26 +00001045 BlockDriverState *bs;
1046 char fmt_name[128], size_buf[128], dsize_buf[128];
ths96b8f132007-12-17 01:35:20 +00001047 uint64_t total_sectors;
1048 int64_t allocated_size;
bellard93b6b2a2006-08-01 15:51:11 +00001049 char backing_filename[1024];
1050 char backing_filename2[1024];
bellardfaea38e2006-08-05 21:31:00 +00001051 BlockDriverInfo bdi;
bellardea2384d2004-08-01 21:59:26 +00001052
1053 fmt = NULL;
1054 for(;;) {
1055 c = getopt(argc, argv, "f:h");
1056 if (c == -1)
1057 break;
1058 switch(c) {
1059 case 'h':
1060 help();
1061 break;
1062 case 'f':
1063 fmt = optarg;
1064 break;
1065 }
1066 }
ths5fafdf22007-09-16 21:08:06 +00001067 if (optind >= argc)
bellardea2384d2004-08-01 21:59:26 +00001068 help();
1069 filename = argv[optind++];
1070
Stefan Hajnocziadfe0782010-04-13 10:29:35 +01001071 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001072 if (!bs) {
1073 return 1;
1074 }
bellardea2384d2004-08-01 21:59:26 +00001075 bdrv_get_format(bs, fmt_name, sizeof(fmt_name));
1076 bdrv_get_geometry(bs, &total_sectors);
1077 get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512);
bellard57d1a2b2004-08-03 21:15:11 +00001078 allocated_size = get_allocated_file_size(filename);
1079 if (allocated_size < 0)
blueswir1a10ea302008-08-24 10:30:33 +00001080 snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
bellardde167e42005-04-28 21:15:08 +00001081 else
ths5fafdf22007-09-16 21:08:06 +00001082 get_human_readable_size(dsize_buf, sizeof(dsize_buf),
bellardde167e42005-04-28 21:15:08 +00001083 allocated_size);
bellardea2384d2004-08-01 21:59:26 +00001084 printf("image: %s\n"
1085 "file format: %s\n"
bellardec3757d2006-06-14 15:50:07 +00001086 "virtual size: %s (%" PRId64 " bytes)\n"
bellardea2384d2004-08-01 21:59:26 +00001087 "disk size: %s\n",
ths5fafdf22007-09-16 21:08:06 +00001088 filename, fmt_name, size_buf,
bellardec3757d2006-06-14 15:50:07 +00001089 (total_sectors * 512),
bellardea2384d2004-08-01 21:59:26 +00001090 dsize_buf);
1091 if (bdrv_is_encrypted(bs))
1092 printf("encrypted: yes\n");
bellardfaea38e2006-08-05 21:31:00 +00001093 if (bdrv_get_info(bs, &bdi) >= 0) {
ths5fafdf22007-09-16 21:08:06 +00001094 if (bdi.cluster_size != 0)
bellardfaea38e2006-08-05 21:31:00 +00001095 printf("cluster_size: %d\n", bdi.cluster_size);
1096 }
bellard93b6b2a2006-08-01 15:51:11 +00001097 bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
bellardfaea38e2006-08-05 21:31:00 +00001098 if (backing_filename[0] != '\0') {
bellard93b6b2a2006-08-01 15:51:11 +00001099 path_combine(backing_filename2, sizeof(backing_filename2),
1100 filename, backing_filename);
ths5fafdf22007-09-16 21:08:06 +00001101 printf("backing file: %s (actual path: %s)\n",
bellard93b6b2a2006-08-01 15:51:11 +00001102 backing_filename,
1103 backing_filename2);
bellardfaea38e2006-08-05 21:31:00 +00001104 }
1105 dump_snapshots(bs);
bellardea2384d2004-08-01 21:59:26 +00001106 bdrv_delete(bs);
1107 return 0;
1108}
1109
aliguorif7b4a942009-01-07 17:40:15 +00001110#define SNAPSHOT_LIST 1
1111#define SNAPSHOT_CREATE 2
1112#define SNAPSHOT_APPLY 3
1113#define SNAPSHOT_DELETE 4
1114
Stuart Brady153859b2009-06-07 00:42:17 +01001115static int img_snapshot(int argc, char **argv)
aliguorif7b4a942009-01-07 17:40:15 +00001116{
1117 BlockDriverState *bs;
1118 QEMUSnapshotInfo sn;
1119 char *filename, *snapshot_name = NULL;
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001120 int c, ret = 0, bdrv_oflags;
aliguorif7b4a942009-01-07 17:40:15 +00001121 int action = 0;
1122 qemu_timeval tv;
1123
Naphtali Spreif5edb012010-01-17 16:48:13 +02001124 bdrv_oflags = BDRV_O_RDWR;
aliguorif7b4a942009-01-07 17:40:15 +00001125 /* Parse commandline parameters */
1126 for(;;) {
1127 c = getopt(argc, argv, "la:c:d:h");
1128 if (c == -1)
1129 break;
1130 switch(c) {
1131 case 'h':
1132 help();
Stuart Brady153859b2009-06-07 00:42:17 +01001133 return 0;
aliguorif7b4a942009-01-07 17:40:15 +00001134 case 'l':
1135 if (action) {
1136 help();
Stuart Brady153859b2009-06-07 00:42:17 +01001137 return 0;
aliguorif7b4a942009-01-07 17:40:15 +00001138 }
1139 action = SNAPSHOT_LIST;
Naphtali Spreif5edb012010-01-17 16:48:13 +02001140 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
aliguorif7b4a942009-01-07 17:40:15 +00001141 break;
1142 case 'a':
1143 if (action) {
1144 help();
Stuart Brady153859b2009-06-07 00:42:17 +01001145 return 0;
aliguorif7b4a942009-01-07 17:40:15 +00001146 }
1147 action = SNAPSHOT_APPLY;
1148 snapshot_name = optarg;
1149 break;
1150 case 'c':
1151 if (action) {
1152 help();
Stuart Brady153859b2009-06-07 00:42:17 +01001153 return 0;
aliguorif7b4a942009-01-07 17:40:15 +00001154 }
1155 action = SNAPSHOT_CREATE;
1156 snapshot_name = optarg;
1157 break;
1158 case 'd':
1159 if (action) {
1160 help();
Stuart Brady153859b2009-06-07 00:42:17 +01001161 return 0;
aliguorif7b4a942009-01-07 17:40:15 +00001162 }
1163 action = SNAPSHOT_DELETE;
1164 snapshot_name = optarg;
1165 break;
1166 }
1167 }
1168
1169 if (optind >= argc)
1170 help();
1171 filename = argv[optind++];
1172
1173 /* Open the image */
Stefan Hajnoczif163d072010-04-13 10:29:34 +01001174 bs = bdrv_new_open(filename, NULL, bdrv_oflags);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001175 if (!bs) {
1176 return 1;
1177 }
aliguorif7b4a942009-01-07 17:40:15 +00001178
1179 /* Perform the requested action */
1180 switch(action) {
1181 case SNAPSHOT_LIST:
1182 dump_snapshots(bs);
1183 break;
1184
1185 case SNAPSHOT_CREATE:
1186 memset(&sn, 0, sizeof(sn));
1187 pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
1188
1189 qemu_gettimeofday(&tv);
1190 sn.date_sec = tv.tv_sec;
1191 sn.date_nsec = tv.tv_usec * 1000;
1192
1193 ret = bdrv_snapshot_create(bs, &sn);
1194 if (ret)
1195 error("Could not create snapshot '%s': %d (%s)",
1196 snapshot_name, ret, strerror(-ret));
1197 break;
1198
1199 case SNAPSHOT_APPLY:
1200 ret = bdrv_snapshot_goto(bs, snapshot_name);
1201 if (ret)
1202 error("Could not apply snapshot '%s': %d (%s)",
1203 snapshot_name, ret, strerror(-ret));
1204 break;
1205
1206 case SNAPSHOT_DELETE:
1207 ret = bdrv_snapshot_delete(bs, snapshot_name);
1208 if (ret)
1209 error("Could not delete snapshot '%s': %d (%s)",
1210 snapshot_name, ret, strerror(-ret));
1211 break;
1212 }
1213
1214 /* Cleanup */
1215 bdrv_delete(bs);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001216 if (ret) {
1217 return 1;
1218 }
Stuart Brady153859b2009-06-07 00:42:17 +01001219 return 0;
aliguorif7b4a942009-01-07 17:40:15 +00001220}
1221
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001222static int img_rebase(int argc, char **argv)
1223{
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001224 BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
Stefan Hajnoczif163d072010-04-13 10:29:34 +01001225 BlockDriver *old_backing_drv, *new_backing_drv;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001226 char *filename;
Kevin Wolfe53dbee2010-03-02 12:14:31 +01001227 const char *fmt, *out_basefmt, *out_baseimg;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001228 int c, flags, ret;
1229 int unsafe = 0;
1230
1231 /* Parse commandline parameters */
Kevin Wolfe53dbee2010-03-02 12:14:31 +01001232 fmt = NULL;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001233 out_baseimg = NULL;
1234 out_basefmt = NULL;
1235
1236 for(;;) {
Kevin Wolfe53dbee2010-03-02 12:14:31 +01001237 c = getopt(argc, argv, "uhf:F:b:");
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001238 if (c == -1)
1239 break;
1240 switch(c) {
1241 case 'h':
1242 help();
1243 return 0;
Kevin Wolfe53dbee2010-03-02 12:14:31 +01001244 case 'f':
1245 fmt = optarg;
1246 break;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001247 case 'F':
1248 out_basefmt = optarg;
1249 break;
1250 case 'b':
1251 out_baseimg = optarg;
1252 break;
1253 case 'u':
1254 unsafe = 1;
1255 break;
1256 }
1257 }
1258
1259 if ((optind >= argc) || !out_baseimg)
1260 help();
1261 filename = argv[optind++];
1262
1263 /*
1264 * Open the images.
1265 *
1266 * Ignore the old backing file for unsafe rebase in case we want to correct
1267 * the reference to a renamed or moved backing file.
1268 */
Stefan Hajnocziadfe0782010-04-13 10:29:35 +01001269 flags = BDRV_O_FLAGS | BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
Stefan Hajnoczif163d072010-04-13 10:29:34 +01001270 bs = bdrv_new_open(filename, fmt, flags);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001271 if (!bs) {
1272 return 1;
1273 }
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001274
1275 /* Find the right drivers for the backing files */
1276 old_backing_drv = NULL;
1277 new_backing_drv = NULL;
1278
1279 if (!unsafe && bs->backing_format[0] != '\0') {
1280 old_backing_drv = bdrv_find_format(bs->backing_format);
1281 if (old_backing_drv == NULL) {
1282 error("Invalid format name: '%s'", bs->backing_format);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001283 ret = -1;
1284 goto out;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001285 }
1286 }
1287
1288 if (out_basefmt != NULL) {
1289 new_backing_drv = bdrv_find_format(out_basefmt);
1290 if (new_backing_drv == NULL) {
1291 error("Invalid format name: '%s'", out_basefmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001292 ret = -1;
1293 goto out;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001294 }
1295 }
1296
1297 /* For safe rebasing we need to compare old and new backing file */
1298 if (unsafe) {
1299 /* Make the compiler happy */
1300 bs_old_backing = NULL;
1301 bs_new_backing = NULL;
1302 } else {
1303 char backing_name[1024];
1304
1305 bs_old_backing = bdrv_new("old_backing");
1306 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001307 ret = bdrv_open(bs_old_backing, backing_name, BDRV_O_FLAGS,
1308 old_backing_drv);
1309 if (ret) {
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001310 error("Could not open old backing file '%s'", backing_name);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001311 goto out;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001312 }
1313
1314 bs_new_backing = bdrv_new("new_backing");
Kevin Wolfcdbae852010-08-17 18:58:55 +02001315 ret = bdrv_open(bs_new_backing, out_baseimg, BDRV_O_FLAGS,
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001316 new_backing_drv);
1317 if (ret) {
Kevin Wolf584771e2010-02-17 12:33:17 +01001318 error("Could not open new backing file '%s'", out_baseimg);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001319 goto out;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001320 }
1321 }
1322
1323 /*
1324 * Check each unallocated cluster in the COW file. If it is unallocated,
1325 * accesses go to the backing file. We must therefore compare this cluster
1326 * in the old and new backing file, and if they differ we need to copy it
1327 * from the old backing file into the COW file.
1328 *
1329 * If qemu-img crashes during this step, no harm is done. The content of
1330 * the image is the same as the original one at any time.
1331 */
1332 if (!unsafe) {
1333 uint64_t num_sectors;
1334 uint64_t sector;
Kevin Wolfcc60e322010-04-29 14:47:48 +02001335 int n;
TeLeMand6771bf2010-02-08 16:20:00 +08001336 uint8_t * buf_old;
1337 uint8_t * buf_new;
1338
1339 buf_old = qemu_malloc(IO_BUF_SIZE);
1340 buf_new = qemu_malloc(IO_BUF_SIZE);
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001341
1342 bdrv_get_geometry(bs, &num_sectors);
1343
1344 for (sector = 0; sector < num_sectors; sector += n) {
1345
1346 /* How many sectors can we handle with the next read? */
1347 if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
1348 n = (IO_BUF_SIZE / 512);
1349 } else {
1350 n = num_sectors - sector;
1351 }
1352
1353 /* If the cluster is allocated, we don't need to take action */
Kevin Wolfcc60e322010-04-29 14:47:48 +02001354 ret = bdrv_is_allocated(bs, sector, n, &n);
1355 if (ret) {
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001356 continue;
1357 }
1358
1359 /* Read old and new backing file */
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001360 ret = bdrv_read(bs_old_backing, sector, buf_old, n);
1361 if (ret < 0) {
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001362 error("error while reading from old backing file");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001363 goto out;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001364 }
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001365 ret = bdrv_read(bs_new_backing, sector, buf_new, n);
1366 if (ret < 0) {
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001367 error("error while reading from new backing file");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001368 goto out;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001369 }
1370
1371 /* If they differ, we need to write to the COW file */
1372 uint64_t written = 0;
1373
1374 while (written < n) {
1375 int pnum;
1376
1377 if (compare_sectors(buf_old + written * 512,
Kevin Wolf60b1bd42010-02-17 12:32:59 +01001378 buf_new + written * 512, n - written, &pnum))
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001379 {
1380 ret = bdrv_write(bs, sector + written,
1381 buf_old + written * 512, pnum);
1382 if (ret < 0) {
1383 error("Error while writing to COW image: %s",
1384 strerror(-ret));
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001385 goto out;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001386 }
1387 }
1388
1389 written += pnum;
1390 }
1391 }
TeLeMand6771bf2010-02-08 16:20:00 +08001392
1393 qemu_free(buf_old);
1394 qemu_free(buf_new);
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001395 }
1396
1397 /*
1398 * Change the backing file. All clusters that are different from the old
1399 * backing file are overwritten in the COW file now, so the visible content
1400 * doesn't change when we switch the backing file.
1401 */
1402 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
1403 if (ret == -ENOSPC) {
1404 error("Could not change the backing file to '%s': No space left in "
1405 "the file header", out_baseimg);
1406 } else if (ret < 0) {
1407 error("Could not change the backing file to '%s': %s",
1408 out_baseimg, strerror(-ret));
1409 }
1410
1411 /*
1412 * TODO At this point it is possible to check if any clusters that are
1413 * allocated in the COW file are the same in the backing file. If so, they
1414 * could be dropped from the COW file. Don't do this before switching the
1415 * backing file, in case of a crash this would lead to corruption.
1416 */
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001417out:
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001418 /* Cleanup */
1419 if (!unsafe) {
1420 bdrv_delete(bs_old_backing);
1421 bdrv_delete(bs_new_backing);
1422 }
1423
1424 bdrv_delete(bs);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001425 if (ret) {
1426 return 1;
1427 }
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001428 return 0;
1429}
1430
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001431static int img_resize(int argc, char **argv)
1432{
1433 int c, ret, relative;
1434 const char *filename, *fmt, *size;
1435 int64_t n, total_size;
1436 BlockDriverState *bs;
1437 QEMUOptionParameter *param;
1438 QEMUOptionParameter resize_options[] = {
1439 {
1440 .name = BLOCK_OPT_SIZE,
1441 .type = OPT_SIZE,
1442 .help = "Virtual disk size"
1443 },
1444 { NULL }
1445 };
1446
1447 fmt = NULL;
1448 for(;;) {
1449 c = getopt(argc, argv, "f:h");
1450 if (c == -1) {
1451 break;
1452 }
1453 switch(c) {
1454 case 'h':
1455 help();
1456 break;
1457 case 'f':
1458 fmt = optarg;
1459 break;
1460 }
1461 }
1462 if (optind + 1 >= argc) {
1463 help();
1464 }
1465 filename = argv[optind++];
1466 size = argv[optind++];
1467
1468 /* Choose grow, shrink, or absolute resize mode */
1469 switch (size[0]) {
1470 case '+':
1471 relative = 1;
1472 size++;
1473 break;
1474 case '-':
1475 relative = -1;
1476 size++;
1477 break;
1478 default:
1479 relative = 0;
1480 break;
1481 }
1482
1483 /* Parse size */
1484 param = parse_option_parameters("", resize_options, NULL);
1485 if (set_option_parameter(param, BLOCK_OPT_SIZE, size)) {
1486 /* Error message already printed when size parsing fails */
1487 exit(1);
1488 }
1489 n = get_option_parameter(param, BLOCK_OPT_SIZE)->value.n;
1490 free_option_parameters(param);
1491
1492 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001493 if (!bs) {
1494 return 1;
1495 }
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001496
1497 if (relative) {
1498 total_size = bdrv_getlength(bs) + n * relative;
1499 } else {
1500 total_size = n;
1501 }
1502 if (total_size <= 0) {
1503 error("New image size must be positive");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001504 ret = -1;
1505 goto out;
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001506 }
1507
1508 ret = bdrv_truncate(bs, total_size);
1509 switch (ret) {
1510 case 0:
1511 printf("Image resized.\n");
1512 break;
1513 case -ENOTSUP:
1514 error("This image format does not support resize");
1515 break;
1516 case -EACCES:
1517 error("Image is read-only");
1518 break;
1519 default:
1520 error("Error resizing image (%d)", -ret);
1521 break;
1522 }
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001523out:
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001524 bdrv_delete(bs);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001525 if (ret) {
1526 return 1;
1527 }
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001528 return 0;
1529}
1530
Anthony Liguoric227f092009-10-01 16:12:16 -05001531static const img_cmd_t img_cmds[] = {
Stuart Brady153859b2009-06-07 00:42:17 +01001532#define DEF(option, callback, arg_string) \
1533 { option, callback },
1534#include "qemu-img-cmds.h"
1535#undef DEF
1536#undef GEN_DOCS
1537 { NULL, NULL, },
1538};
1539
bellardea2384d2004-08-01 21:59:26 +00001540int main(int argc, char **argv)
1541{
Anthony Liguoric227f092009-10-01 16:12:16 -05001542 const img_cmd_t *cmd;
Stuart Brady153859b2009-06-07 00:42:17 +01001543 const char *cmdname;
bellardea2384d2004-08-01 21:59:26 +00001544
1545 bdrv_init();
1546 if (argc < 2)
1547 help();
Stuart Brady153859b2009-06-07 00:42:17 +01001548 cmdname = argv[1];
aurel328f9b1572009-02-09 18:14:31 +00001549 argc--; argv++;
Stuart Brady153859b2009-06-07 00:42:17 +01001550
1551 /* find the command */
1552 for(cmd = img_cmds; cmd->name != NULL; cmd++) {
1553 if (!strcmp(cmdname, cmd->name)) {
1554 return cmd->handler(argc, argv);
1555 }
bellardea2384d2004-08-01 21:59:26 +00001556 }
Stuart Brady153859b2009-06-07 00:42:17 +01001557
1558 /* not found */
1559 help();
bellardea2384d2004-08-01 21:59:26 +00001560 return 0;
1561}