blob: aded72d49fa79730126562dd28f9a8bb2353dda5 [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");
Jes Sorensen31ca34b2010-12-06 15:25:36 +0100699 ret = -1;
700 goto out;
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900701 }
balrog926c2d22007-10-31 01:11:44 +0000702
Jes Sorensen5bdf61f2010-12-06 15:25:35 +0100703 bs = qemu_mallocz(bs_n * sizeof(BlockDriverState *));
balrog926c2d22007-10-31 01:11:44 +0000704
705 total_sectors = 0;
706 for (bs_i = 0; bs_i < bs_n; bs_i++) {
Stefan Hajnocziadfe0782010-04-13 10:29:35 +0100707 bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, BDRV_O_FLAGS);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900708 if (!bs[bs_i]) {
balrog926c2d22007-10-31 01:11:44 +0000709 error("Could not open '%s'", argv[optind + bs_i]);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900710 ret = -1;
711 goto out;
712 }
balrog926c2d22007-10-31 01:11:44 +0000713 bdrv_get_geometry(bs[bs_i], &bs_sectors);
714 total_sectors += bs_sectors;
715 }
bellardea2384d2004-08-01 21:59:26 +0000716
edison51ef6722010-09-21 19:58:41 -0700717 if (snapshot_name != NULL) {
718 if (bs_n > 1) {
719 error("No support for concatenating multiple snapshot\n");
720 ret = -1;
721 goto out;
722 }
723 if (bdrv_snapshot_load_tmp(bs[0], snapshot_name) < 0) {
724 error("Failed to load snapshot\n");
725 ret = -1;
726 goto out;
727 }
728 }
729
Kevin Wolfefa84d42009-05-18 16:42:12 +0200730 /* Find driver and parse its options */
bellardea2384d2004-08-01 21:59:26 +0000731 drv = bdrv_find_format(out_fmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900732 if (!drv) {
thsd34dda52007-02-10 22:59:40 +0000733 error("Unknown file format '%s'", out_fmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900734 ret = -1;
735 goto out;
736 }
balrog926c2d22007-10-31 01:11:44 +0000737
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900738 proto_drv = bdrv_find_protocol(out_filename);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900739 if (!proto_drv) {
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900740 error("Unknown protocol '%s'", out_filename);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900741 ret = -1;
742 goto out;
743 }
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900744
745 create_options = append_option_parameters(create_options,
746 drv->create_options);
747 create_options = append_option_parameters(create_options,
748 proto_drv->create_options);
Kevin Wolfdb08adf2009-06-04 15:39:38 +0200749 if (options && !strcmp(options, "?")) {
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900750 print_option_help(create_options);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900751 goto out;
Kevin Wolfdb08adf2009-06-04 15:39:38 +0200752 }
753
Kevin Wolfefa84d42009-05-18 16:42:12 +0200754 if (options) {
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900755 param = parse_option_parameters(options, create_options, param);
Kevin Wolfefa84d42009-05-18 16:42:12 +0200756 if (param == NULL) {
757 error("Invalid options for file format '%s'.", out_fmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900758 ret = -1;
759 goto out;
Kevin Wolfefa84d42009-05-18 16:42:12 +0200760 }
761 } else {
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900762 param = parse_option_parameters("", create_options, param);
Kevin Wolfefa84d42009-05-18 16:42:12 +0200763 }
764
765 set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900766 ret = add_old_style_options(out_fmt, param, flags, out_baseimg, NULL);
767 if (ret < 0) {
768 goto out;
769 }
Kevin Wolfefa84d42009-05-18 16:42:12 +0200770
Kevin Wolfa18953f2010-10-14 15:46:04 +0200771 /* Get backing file name if -o backing_file was used */
772 out_baseimg_param = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
773 if (out_baseimg_param) {
774 out_baseimg = out_baseimg_param->value.s;
775 }
776
Kevin Wolfefa84d42009-05-18 16:42:12 +0200777 /* Check if compression is supported */
778 if (flags & BLOCK_FLAG_COMPRESS) {
779 QEMUOptionParameter *encryption =
780 get_option_parameter(param, BLOCK_OPT_ENCRYPT);
781
782 if (!drv->bdrv_write_compressed) {
783 error("Compression not supported for this file format");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900784 ret = -1;
785 goto out;
Kevin Wolfefa84d42009-05-18 16:42:12 +0200786 }
787
788 if (encryption && encryption->value.n) {
789 error("Compression and encryption not supported at the same time");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900790 ret = -1;
791 goto out;
Kevin Wolfefa84d42009-05-18 16:42:12 +0200792 }
793 }
794
795 /* Create the new image */
796 ret = bdrv_create(drv, out_filename, param);
bellardea2384d2004-08-01 21:59:26 +0000797 if (ret < 0) {
798 if (ret == -ENOTSUP) {
aliguori93c65b42009-04-05 17:40:43 +0000799 error("Formatting not supported for file format '%s'", out_fmt);
aurel326e9ea0c2009-04-15 14:42:46 +0000800 } else if (ret == -EFBIG) {
801 error("The image size is too large for file format '%s'", out_fmt);
bellardea2384d2004-08-01 21:59:26 +0000802 } else {
Juan Quintela3e7896d2010-03-04 10:00:38 +0100803 error("%s: error while converting %s: %s", out_filename, out_fmt, strerror(-ret));
bellardea2384d2004-08-01 21:59:26 +0000804 }
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900805 goto out;
bellardea2384d2004-08-01 21:59:26 +0000806 }
ths3b46e622007-09-17 08:09:54 +0000807
Kevin Wolf1bd8e172010-08-31 13:44:25 +0200808 out_bs = bdrv_new_open(out_filename, out_fmt,
809 BDRV_O_FLAGS | BDRV_O_RDWR | BDRV_O_NO_FLUSH);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900810 if (!out_bs) {
811 ret = -1;
812 goto out;
813 }
bellardea2384d2004-08-01 21:59:26 +0000814
balrog926c2d22007-10-31 01:11:44 +0000815 bs_i = 0;
816 bs_offset = 0;
817 bdrv_get_geometry(bs[0], &bs_sectors);
TeLeMand6771bf2010-02-08 16:20:00 +0800818 buf = qemu_malloc(IO_BUF_SIZE);
balrog926c2d22007-10-31 01:11:44 +0000819
820 if (flags & BLOCK_FLAG_COMPRESS) {
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900821 ret = bdrv_get_info(out_bs, &bdi);
822 if (ret < 0) {
bellardfaea38e2006-08-05 21:31:00 +0000823 error("could not get block driver info");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900824 goto out;
825 }
bellardfaea38e2006-08-05 21:31:00 +0000826 cluster_size = bdi.cluster_size;
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900827 if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) {
bellardea2384d2004-08-01 21:59:26 +0000828 error("invalid cluster size");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900829 ret = -1;
830 goto out;
831 }
bellardea2384d2004-08-01 21:59:26 +0000832 cluster_sectors = cluster_size >> 9;
833 sector_num = 0;
834 for(;;) {
balrog926c2d22007-10-31 01:11:44 +0000835 int64_t bs_num;
836 int remainder;
837 uint8_t *buf2;
838
bellardea2384d2004-08-01 21:59:26 +0000839 nb_sectors = total_sectors - sector_num;
840 if (nb_sectors <= 0)
841 break;
842 if (nb_sectors >= cluster_sectors)
843 n = cluster_sectors;
844 else
845 n = nb_sectors;
balrog926c2d22007-10-31 01:11:44 +0000846
847 bs_num = sector_num - bs_offset;
848 assert (bs_num >= 0);
849 remainder = n;
850 buf2 = buf;
851 while (remainder > 0) {
852 int nlow;
853 while (bs_num == bs_sectors) {
854 bs_i++;
855 assert (bs_i < bs_n);
856 bs_offset += bs_sectors;
857 bdrv_get_geometry(bs[bs_i], &bs_sectors);
858 bs_num = 0;
Blue Swirl0bfcd592010-05-22 08:02:12 +0000859 /* printf("changing part: sector_num=%" PRId64 ", "
860 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
861 "\n", sector_num, bs_i, bs_offset, bs_sectors); */
balrog926c2d22007-10-31 01:11:44 +0000862 }
863 assert (bs_num < bs_sectors);
864
865 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;
866
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900867 ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow);
868 if (ret < 0) {
balrog926c2d22007-10-31 01:11:44 +0000869 error("error while reading");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900870 goto out;
871 }
balrog926c2d22007-10-31 01:11:44 +0000872
873 buf2 += nlow * 512;
874 bs_num += nlow;
875
876 remainder -= nlow;
877 }
878 assert (remainder == 0);
879
bellardea2384d2004-08-01 21:59:26 +0000880 if (n < cluster_sectors)
881 memset(buf + n * 512, 0, cluster_size - n * 512);
882 if (is_not_zero(buf, cluster_size)) {
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900883 ret = bdrv_write_compressed(out_bs, sector_num, buf,
884 cluster_sectors);
885 if (ret != 0) {
bellardec3757d2006-06-14 15:50:07 +0000886 error("error while compressing sector %" PRId64,
887 sector_num);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900888 goto out;
889 }
bellardea2384d2004-08-01 21:59:26 +0000890 }
891 sector_num += n;
892 }
bellardfaea38e2006-08-05 21:31:00 +0000893 /* signal EOF to align */
894 bdrv_write_compressed(out_bs, 0, NULL, 0);
bellardea2384d2004-08-01 21:59:26 +0000895 } else {
Kevin Wolff2feebb2010-04-14 17:30:35 +0200896 int has_zero_init = bdrv_has_zero_init(out_bs);
897
thsf58c7b32008-06-05 21:53:49 +0000898 sector_num = 0; // total number of sectors converted so far
bellardea2384d2004-08-01 21:59:26 +0000899 for(;;) {
900 nb_sectors = total_sectors - sector_num;
901 if (nb_sectors <= 0)
902 break;
903 if (nb_sectors >= (IO_BUF_SIZE / 512))
904 n = (IO_BUF_SIZE / 512);
905 else
906 n = nb_sectors;
balrog926c2d22007-10-31 01:11:44 +0000907
908 while (sector_num - bs_offset >= bs_sectors) {
909 bs_i ++;
910 assert (bs_i < bs_n);
911 bs_offset += bs_sectors;
912 bdrv_get_geometry(bs[bs_i], &bs_sectors);
Blue Swirl0bfcd592010-05-22 08:02:12 +0000913 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
914 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
balrog926c2d22007-10-31 01:11:44 +0000915 sector_num, bs_i, bs_offset, bs_sectors); */
916 }
917
918 if (n > bs_offset + bs_sectors - sector_num)
919 n = bs_offset + bs_sectors - sector_num;
920
Kevin Wolff2feebb2010-04-14 17:30:35 +0200921 if (has_zero_init) {
Akkarit Sangpetchd0320442009-07-17 10:02:15 +0200922 /* If the output image is being created as a copy on write image,
923 assume that sectors which are unallocated in the input image
924 are present in both the output's and input's base images (no
925 need to copy them). */
926 if (out_baseimg) {
927 if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
928 n, &n1)) {
929 sector_num += n1;
930 continue;
931 }
932 /* The next 'n1' sectors are allocated in the input image. Copy
933 only those as they may be followed by unallocated sectors. */
934 n = n1;
aliguori93c65b42009-04-05 17:40:43 +0000935 }
aliguori93c65b42009-04-05 17:40:43 +0000936 } else {
937 n1 = n;
thsf58c7b32008-06-05 21:53:49 +0000938 }
939
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900940 ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
941 if (ret < 0) {
bellardea2384d2004-08-01 21:59:26 +0000942 error("error while reading");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900943 goto out;
944 }
bellardea2384d2004-08-01 21:59:26 +0000945 /* NOTE: at the same time we convert, we do not write zero
946 sectors to have a chance to compress the image. Ideally, we
947 should add a specific call to have the info to go faster */
948 buf1 = buf;
949 while (n > 0) {
thsf58c7b32008-06-05 21:53:49 +0000950 /* If the output image is being created as a copy on write image,
951 copy all sectors even the ones containing only NUL bytes,
aliguori93c65b42009-04-05 17:40:43 +0000952 because they may differ from the sectors in the base image.
953
954 If the output is to a host device, we also write out
955 sectors that are entirely 0, since whatever data was
956 already there is garbage, not 0s. */
Kevin Wolff2feebb2010-04-14 17:30:35 +0200957 if (!has_zero_init || out_baseimg ||
aliguori93c65b42009-04-05 17:40:43 +0000958 is_allocated_sectors(buf1, n, &n1)) {
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900959 ret = bdrv_write(out_bs, sector_num, buf1, n1);
960 if (ret < 0) {
bellardea2384d2004-08-01 21:59:26 +0000961 error("error while writing");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900962 goto out;
963 }
bellardea2384d2004-08-01 21:59:26 +0000964 }
965 sector_num += n1;
966 n -= n1;
967 buf1 += n1 * 512;
968 }
969 }
970 }
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900971out:
972 free_option_parameters(create_options);
973 free_option_parameters(param);
TeLeMand6771bf2010-02-08 16:20:00 +0800974 qemu_free(buf);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900975 if (out_bs) {
976 bdrv_delete(out_bs);
977 }
Jes Sorensen31ca34b2010-12-06 15:25:36 +0100978 if (bs) {
979 for (bs_i = 0; bs_i < bs_n; bs_i++) {
980 if (bs[bs_i]) {
981 bdrv_delete(bs[bs_i]);
982 }
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900983 }
Jes Sorensen31ca34b2010-12-06 15:25:36 +0100984 qemu_free(bs);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900985 }
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900986 if (ret) {
987 return 1;
988 }
bellardea2384d2004-08-01 21:59:26 +0000989 return 0;
990}
991
bellard57d1a2b2004-08-03 21:15:11 +0000992#ifdef _WIN32
993static int64_t get_allocated_file_size(const char *filename)
994{
bellarde8445332006-06-14 15:32:10 +0000995 typedef DWORD (WINAPI * get_compressed_t)(const char *filename, DWORD *high);
996 get_compressed_t get_compressed;
bellard57d1a2b2004-08-03 21:15:11 +0000997 struct _stati64 st;
bellarde8445332006-06-14 15:32:10 +0000998
999 /* WinNT support GetCompressedFileSize to determine allocate size */
1000 get_compressed = (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA");
1001 if (get_compressed) {
1002 DWORD high, low;
1003 low = get_compressed(filename, &high);
1004 if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR)
1005 return (((int64_t) high) << 32) + low;
1006 }
1007
ths5fafdf22007-09-16 21:08:06 +00001008 if (_stati64(filename, &st) < 0)
bellard57d1a2b2004-08-03 21:15:11 +00001009 return -1;
1010 return st.st_size;
1011}
1012#else
1013static int64_t get_allocated_file_size(const char *filename)
1014{
1015 struct stat st;
ths5fafdf22007-09-16 21:08:06 +00001016 if (stat(filename, &st) < 0)
bellard57d1a2b2004-08-03 21:15:11 +00001017 return -1;
1018 return (int64_t)st.st_blocks * 512;
1019}
1020#endif
1021
bellardfaea38e2006-08-05 21:31:00 +00001022static void dump_snapshots(BlockDriverState *bs)
1023{
1024 QEMUSnapshotInfo *sn_tab, *sn;
1025 int nb_sns, i;
1026 char buf[256];
1027
1028 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1029 if (nb_sns <= 0)
1030 return;
1031 printf("Snapshot list:\n");
1032 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
1033 for(i = 0; i < nb_sns; i++) {
1034 sn = &sn_tab[i];
1035 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
1036 }
1037 qemu_free(sn_tab);
1038}
1039
bellardea2384d2004-08-01 21:59:26 +00001040static int img_info(int argc, char **argv)
1041{
1042 int c;
1043 const char *filename, *fmt;
bellardea2384d2004-08-01 21:59:26 +00001044 BlockDriverState *bs;
1045 char fmt_name[128], size_buf[128], dsize_buf[128];
ths96b8f132007-12-17 01:35:20 +00001046 uint64_t total_sectors;
1047 int64_t allocated_size;
bellard93b6b2a2006-08-01 15:51:11 +00001048 char backing_filename[1024];
1049 char backing_filename2[1024];
bellardfaea38e2006-08-05 21:31:00 +00001050 BlockDriverInfo bdi;
bellardea2384d2004-08-01 21:59:26 +00001051
1052 fmt = NULL;
1053 for(;;) {
1054 c = getopt(argc, argv, "f:h");
1055 if (c == -1)
1056 break;
1057 switch(c) {
1058 case 'h':
1059 help();
1060 break;
1061 case 'f':
1062 fmt = optarg;
1063 break;
1064 }
1065 }
ths5fafdf22007-09-16 21:08:06 +00001066 if (optind >= argc)
bellardea2384d2004-08-01 21:59:26 +00001067 help();
1068 filename = argv[optind++];
1069
Stefan Hajnocziadfe0782010-04-13 10:29:35 +01001070 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001071 if (!bs) {
1072 return 1;
1073 }
bellardea2384d2004-08-01 21:59:26 +00001074 bdrv_get_format(bs, fmt_name, sizeof(fmt_name));
1075 bdrv_get_geometry(bs, &total_sectors);
1076 get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512);
bellard57d1a2b2004-08-03 21:15:11 +00001077 allocated_size = get_allocated_file_size(filename);
1078 if (allocated_size < 0)
blueswir1a10ea302008-08-24 10:30:33 +00001079 snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
bellardde167e42005-04-28 21:15:08 +00001080 else
ths5fafdf22007-09-16 21:08:06 +00001081 get_human_readable_size(dsize_buf, sizeof(dsize_buf),
bellardde167e42005-04-28 21:15:08 +00001082 allocated_size);
bellardea2384d2004-08-01 21:59:26 +00001083 printf("image: %s\n"
1084 "file format: %s\n"
bellardec3757d2006-06-14 15:50:07 +00001085 "virtual size: %s (%" PRId64 " bytes)\n"
bellardea2384d2004-08-01 21:59:26 +00001086 "disk size: %s\n",
ths5fafdf22007-09-16 21:08:06 +00001087 filename, fmt_name, size_buf,
bellardec3757d2006-06-14 15:50:07 +00001088 (total_sectors * 512),
bellardea2384d2004-08-01 21:59:26 +00001089 dsize_buf);
1090 if (bdrv_is_encrypted(bs))
1091 printf("encrypted: yes\n");
bellardfaea38e2006-08-05 21:31:00 +00001092 if (bdrv_get_info(bs, &bdi) >= 0) {
ths5fafdf22007-09-16 21:08:06 +00001093 if (bdi.cluster_size != 0)
bellardfaea38e2006-08-05 21:31:00 +00001094 printf("cluster_size: %d\n", bdi.cluster_size);
1095 }
bellard93b6b2a2006-08-01 15:51:11 +00001096 bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
bellardfaea38e2006-08-05 21:31:00 +00001097 if (backing_filename[0] != '\0') {
bellard93b6b2a2006-08-01 15:51:11 +00001098 path_combine(backing_filename2, sizeof(backing_filename2),
1099 filename, backing_filename);
ths5fafdf22007-09-16 21:08:06 +00001100 printf("backing file: %s (actual path: %s)\n",
bellard93b6b2a2006-08-01 15:51:11 +00001101 backing_filename,
1102 backing_filename2);
bellardfaea38e2006-08-05 21:31:00 +00001103 }
1104 dump_snapshots(bs);
bellardea2384d2004-08-01 21:59:26 +00001105 bdrv_delete(bs);
1106 return 0;
1107}
1108
aliguorif7b4a942009-01-07 17:40:15 +00001109#define SNAPSHOT_LIST 1
1110#define SNAPSHOT_CREATE 2
1111#define SNAPSHOT_APPLY 3
1112#define SNAPSHOT_DELETE 4
1113
Stuart Brady153859b2009-06-07 00:42:17 +01001114static int img_snapshot(int argc, char **argv)
aliguorif7b4a942009-01-07 17:40:15 +00001115{
1116 BlockDriverState *bs;
1117 QEMUSnapshotInfo sn;
1118 char *filename, *snapshot_name = NULL;
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001119 int c, ret = 0, bdrv_oflags;
aliguorif7b4a942009-01-07 17:40:15 +00001120 int action = 0;
1121 qemu_timeval tv;
1122
Naphtali Spreif5edb012010-01-17 16:48:13 +02001123 bdrv_oflags = BDRV_O_RDWR;
aliguorif7b4a942009-01-07 17:40:15 +00001124 /* Parse commandline parameters */
1125 for(;;) {
1126 c = getopt(argc, argv, "la:c:d:h");
1127 if (c == -1)
1128 break;
1129 switch(c) {
1130 case 'h':
1131 help();
Stuart Brady153859b2009-06-07 00:42:17 +01001132 return 0;
aliguorif7b4a942009-01-07 17:40:15 +00001133 case 'l':
1134 if (action) {
1135 help();
Stuart Brady153859b2009-06-07 00:42:17 +01001136 return 0;
aliguorif7b4a942009-01-07 17:40:15 +00001137 }
1138 action = SNAPSHOT_LIST;
Naphtali Spreif5edb012010-01-17 16:48:13 +02001139 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
aliguorif7b4a942009-01-07 17:40:15 +00001140 break;
1141 case 'a':
1142 if (action) {
1143 help();
Stuart Brady153859b2009-06-07 00:42:17 +01001144 return 0;
aliguorif7b4a942009-01-07 17:40:15 +00001145 }
1146 action = SNAPSHOT_APPLY;
1147 snapshot_name = optarg;
1148 break;
1149 case 'c':
1150 if (action) {
1151 help();
Stuart Brady153859b2009-06-07 00:42:17 +01001152 return 0;
aliguorif7b4a942009-01-07 17:40:15 +00001153 }
1154 action = SNAPSHOT_CREATE;
1155 snapshot_name = optarg;
1156 break;
1157 case 'd':
1158 if (action) {
1159 help();
Stuart Brady153859b2009-06-07 00:42:17 +01001160 return 0;
aliguorif7b4a942009-01-07 17:40:15 +00001161 }
1162 action = SNAPSHOT_DELETE;
1163 snapshot_name = optarg;
1164 break;
1165 }
1166 }
1167
1168 if (optind >= argc)
1169 help();
1170 filename = argv[optind++];
1171
1172 /* Open the image */
Stefan Hajnoczif163d072010-04-13 10:29:34 +01001173 bs = bdrv_new_open(filename, NULL, bdrv_oflags);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001174 if (!bs) {
1175 return 1;
1176 }
aliguorif7b4a942009-01-07 17:40:15 +00001177
1178 /* Perform the requested action */
1179 switch(action) {
1180 case SNAPSHOT_LIST:
1181 dump_snapshots(bs);
1182 break;
1183
1184 case SNAPSHOT_CREATE:
1185 memset(&sn, 0, sizeof(sn));
1186 pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
1187
1188 qemu_gettimeofday(&tv);
1189 sn.date_sec = tv.tv_sec;
1190 sn.date_nsec = tv.tv_usec * 1000;
1191
1192 ret = bdrv_snapshot_create(bs, &sn);
1193 if (ret)
1194 error("Could not create snapshot '%s': %d (%s)",
1195 snapshot_name, ret, strerror(-ret));
1196 break;
1197
1198 case SNAPSHOT_APPLY:
1199 ret = bdrv_snapshot_goto(bs, snapshot_name);
1200 if (ret)
1201 error("Could not apply snapshot '%s': %d (%s)",
1202 snapshot_name, ret, strerror(-ret));
1203 break;
1204
1205 case SNAPSHOT_DELETE:
1206 ret = bdrv_snapshot_delete(bs, snapshot_name);
1207 if (ret)
1208 error("Could not delete snapshot '%s': %d (%s)",
1209 snapshot_name, ret, strerror(-ret));
1210 break;
1211 }
1212
1213 /* Cleanup */
1214 bdrv_delete(bs);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001215 if (ret) {
1216 return 1;
1217 }
Stuart Brady153859b2009-06-07 00:42:17 +01001218 return 0;
aliguorif7b4a942009-01-07 17:40:15 +00001219}
1220
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001221static int img_rebase(int argc, char **argv)
1222{
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001223 BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
Stefan Hajnoczif163d072010-04-13 10:29:34 +01001224 BlockDriver *old_backing_drv, *new_backing_drv;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001225 char *filename;
Kevin Wolfe53dbee2010-03-02 12:14:31 +01001226 const char *fmt, *out_basefmt, *out_baseimg;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001227 int c, flags, ret;
1228 int unsafe = 0;
1229
1230 /* Parse commandline parameters */
Kevin Wolfe53dbee2010-03-02 12:14:31 +01001231 fmt = NULL;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001232 out_baseimg = NULL;
1233 out_basefmt = NULL;
1234
1235 for(;;) {
Kevin Wolfe53dbee2010-03-02 12:14:31 +01001236 c = getopt(argc, argv, "uhf:F:b:");
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001237 if (c == -1)
1238 break;
1239 switch(c) {
1240 case 'h':
1241 help();
1242 return 0;
Kevin Wolfe53dbee2010-03-02 12:14:31 +01001243 case 'f':
1244 fmt = optarg;
1245 break;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001246 case 'F':
1247 out_basefmt = optarg;
1248 break;
1249 case 'b':
1250 out_baseimg = optarg;
1251 break;
1252 case 'u':
1253 unsafe = 1;
1254 break;
1255 }
1256 }
1257
1258 if ((optind >= argc) || !out_baseimg)
1259 help();
1260 filename = argv[optind++];
1261
1262 /*
1263 * Open the images.
1264 *
1265 * Ignore the old backing file for unsafe rebase in case we want to correct
1266 * the reference to a renamed or moved backing file.
1267 */
Stefan Hajnocziadfe0782010-04-13 10:29:35 +01001268 flags = BDRV_O_FLAGS | BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
Stefan Hajnoczif163d072010-04-13 10:29:34 +01001269 bs = bdrv_new_open(filename, fmt, flags);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001270 if (!bs) {
1271 return 1;
1272 }
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001273
1274 /* Find the right drivers for the backing files */
1275 old_backing_drv = NULL;
1276 new_backing_drv = NULL;
1277
1278 if (!unsafe && bs->backing_format[0] != '\0') {
1279 old_backing_drv = bdrv_find_format(bs->backing_format);
1280 if (old_backing_drv == NULL) {
1281 error("Invalid format name: '%s'", bs->backing_format);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001282 ret = -1;
1283 goto out;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001284 }
1285 }
1286
1287 if (out_basefmt != NULL) {
1288 new_backing_drv = bdrv_find_format(out_basefmt);
1289 if (new_backing_drv == NULL) {
1290 error("Invalid format name: '%s'", out_basefmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001291 ret = -1;
1292 goto out;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001293 }
1294 }
1295
1296 /* For safe rebasing we need to compare old and new backing file */
1297 if (unsafe) {
1298 /* Make the compiler happy */
1299 bs_old_backing = NULL;
1300 bs_new_backing = NULL;
1301 } else {
1302 char backing_name[1024];
1303
1304 bs_old_backing = bdrv_new("old_backing");
1305 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001306 ret = bdrv_open(bs_old_backing, backing_name, BDRV_O_FLAGS,
1307 old_backing_drv);
1308 if (ret) {
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001309 error("Could not open old backing file '%s'", backing_name);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001310 goto out;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001311 }
1312
1313 bs_new_backing = bdrv_new("new_backing");
Kevin Wolfcdbae852010-08-17 18:58:55 +02001314 ret = bdrv_open(bs_new_backing, out_baseimg, BDRV_O_FLAGS,
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001315 new_backing_drv);
1316 if (ret) {
Kevin Wolf584771e2010-02-17 12:33:17 +01001317 error("Could not open new backing file '%s'", out_baseimg);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001318 goto out;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001319 }
1320 }
1321
1322 /*
1323 * Check each unallocated cluster in the COW file. If it is unallocated,
1324 * accesses go to the backing file. We must therefore compare this cluster
1325 * in the old and new backing file, and if they differ we need to copy it
1326 * from the old backing file into the COW file.
1327 *
1328 * If qemu-img crashes during this step, no harm is done. The content of
1329 * the image is the same as the original one at any time.
1330 */
1331 if (!unsafe) {
1332 uint64_t num_sectors;
1333 uint64_t sector;
Kevin Wolfcc60e322010-04-29 14:47:48 +02001334 int n;
TeLeMand6771bf2010-02-08 16:20:00 +08001335 uint8_t * buf_old;
1336 uint8_t * buf_new;
1337
1338 buf_old = qemu_malloc(IO_BUF_SIZE);
1339 buf_new = qemu_malloc(IO_BUF_SIZE);
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001340
1341 bdrv_get_geometry(bs, &num_sectors);
1342
1343 for (sector = 0; sector < num_sectors; sector += n) {
1344
1345 /* How many sectors can we handle with the next read? */
1346 if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
1347 n = (IO_BUF_SIZE / 512);
1348 } else {
1349 n = num_sectors - sector;
1350 }
1351
1352 /* If the cluster is allocated, we don't need to take action */
Kevin Wolfcc60e322010-04-29 14:47:48 +02001353 ret = bdrv_is_allocated(bs, sector, n, &n);
1354 if (ret) {
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001355 continue;
1356 }
1357
1358 /* Read old and new backing file */
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001359 ret = bdrv_read(bs_old_backing, sector, buf_old, n);
1360 if (ret < 0) {
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001361 error("error while reading from old backing file");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001362 goto out;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001363 }
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001364 ret = bdrv_read(bs_new_backing, sector, buf_new, n);
1365 if (ret < 0) {
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001366 error("error while reading from new backing file");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001367 goto out;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001368 }
1369
1370 /* If they differ, we need to write to the COW file */
1371 uint64_t written = 0;
1372
1373 while (written < n) {
1374 int pnum;
1375
1376 if (compare_sectors(buf_old + written * 512,
Kevin Wolf60b1bd42010-02-17 12:32:59 +01001377 buf_new + written * 512, n - written, &pnum))
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001378 {
1379 ret = bdrv_write(bs, sector + written,
1380 buf_old + written * 512, pnum);
1381 if (ret < 0) {
1382 error("Error while writing to COW image: %s",
1383 strerror(-ret));
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001384 goto out;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001385 }
1386 }
1387
1388 written += pnum;
1389 }
1390 }
TeLeMand6771bf2010-02-08 16:20:00 +08001391
1392 qemu_free(buf_old);
1393 qemu_free(buf_new);
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001394 }
1395
1396 /*
1397 * Change the backing file. All clusters that are different from the old
1398 * backing file are overwritten in the COW file now, so the visible content
1399 * doesn't change when we switch the backing file.
1400 */
1401 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
1402 if (ret == -ENOSPC) {
1403 error("Could not change the backing file to '%s': No space left in "
1404 "the file header", out_baseimg);
1405 } else if (ret < 0) {
1406 error("Could not change the backing file to '%s': %s",
1407 out_baseimg, strerror(-ret));
1408 }
1409
1410 /*
1411 * TODO At this point it is possible to check if any clusters that are
1412 * allocated in the COW file are the same in the backing file. If so, they
1413 * could be dropped from the COW file. Don't do this before switching the
1414 * backing file, in case of a crash this would lead to corruption.
1415 */
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001416out:
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001417 /* Cleanup */
1418 if (!unsafe) {
1419 bdrv_delete(bs_old_backing);
1420 bdrv_delete(bs_new_backing);
1421 }
1422
1423 bdrv_delete(bs);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001424 if (ret) {
1425 return 1;
1426 }
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001427 return 0;
1428}
1429
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001430static int img_resize(int argc, char **argv)
1431{
1432 int c, ret, relative;
1433 const char *filename, *fmt, *size;
1434 int64_t n, total_size;
1435 BlockDriverState *bs;
1436 QEMUOptionParameter *param;
1437 QEMUOptionParameter resize_options[] = {
1438 {
1439 .name = BLOCK_OPT_SIZE,
1440 .type = OPT_SIZE,
1441 .help = "Virtual disk size"
1442 },
1443 { NULL }
1444 };
1445
1446 fmt = NULL;
1447 for(;;) {
1448 c = getopt(argc, argv, "f:h");
1449 if (c == -1) {
1450 break;
1451 }
1452 switch(c) {
1453 case 'h':
1454 help();
1455 break;
1456 case 'f':
1457 fmt = optarg;
1458 break;
1459 }
1460 }
1461 if (optind + 1 >= argc) {
1462 help();
1463 }
1464 filename = argv[optind++];
1465 size = argv[optind++];
1466
1467 /* Choose grow, shrink, or absolute resize mode */
1468 switch (size[0]) {
1469 case '+':
1470 relative = 1;
1471 size++;
1472 break;
1473 case '-':
1474 relative = -1;
1475 size++;
1476 break;
1477 default:
1478 relative = 0;
1479 break;
1480 }
1481
1482 /* Parse size */
1483 param = parse_option_parameters("", resize_options, NULL);
1484 if (set_option_parameter(param, BLOCK_OPT_SIZE, size)) {
1485 /* Error message already printed when size parsing fails */
1486 exit(1);
1487 }
1488 n = get_option_parameter(param, BLOCK_OPT_SIZE)->value.n;
1489 free_option_parameters(param);
1490
1491 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001492 if (!bs) {
1493 return 1;
1494 }
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001495
1496 if (relative) {
1497 total_size = bdrv_getlength(bs) + n * relative;
1498 } else {
1499 total_size = n;
1500 }
1501 if (total_size <= 0) {
1502 error("New image size must be positive");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001503 ret = -1;
1504 goto out;
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001505 }
1506
1507 ret = bdrv_truncate(bs, total_size);
1508 switch (ret) {
1509 case 0:
1510 printf("Image resized.\n");
1511 break;
1512 case -ENOTSUP:
1513 error("This image format does not support resize");
1514 break;
1515 case -EACCES:
1516 error("Image is read-only");
1517 break;
1518 default:
1519 error("Error resizing image (%d)", -ret);
1520 break;
1521 }
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001522out:
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001523 bdrv_delete(bs);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001524 if (ret) {
1525 return 1;
1526 }
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001527 return 0;
1528}
1529
Anthony Liguoric227f092009-10-01 16:12:16 -05001530static const img_cmd_t img_cmds[] = {
Stuart Brady153859b2009-06-07 00:42:17 +01001531#define DEF(option, callback, arg_string) \
1532 { option, callback },
1533#include "qemu-img-cmds.h"
1534#undef DEF
1535#undef GEN_DOCS
1536 { NULL, NULL, },
1537};
1538
bellardea2384d2004-08-01 21:59:26 +00001539int main(int argc, char **argv)
1540{
Anthony Liguoric227f092009-10-01 16:12:16 -05001541 const img_cmd_t *cmd;
Stuart Brady153859b2009-06-07 00:42:17 +01001542 const char *cmdname;
bellardea2384d2004-08-01 21:59:26 +00001543
1544 bdrv_init();
1545 if (argc < 2)
1546 help();
Stuart Brady153859b2009-06-07 00:42:17 +01001547 cmdname = argv[1];
aurel328f9b1572009-02-09 18:14:31 +00001548 argc--; argv++;
Stuart Brady153859b2009-06-07 00:42:17 +01001549
1550 /* find the command */
1551 for(cmd = img_cmds; cmd->name != NULL; cmd++) {
1552 if (!strcmp(cmdname, cmd->name)) {
1553 return cmd->handler(argc, argv);
1554 }
bellardea2384d2004-08-01 21:59:26 +00001555 }
Stuart Brady153859b2009-06-07 00:42:17 +01001556
1557 /* not found */
1558 help();
bellardea2384d2004-08-01 21:59:26 +00001559 return 0;
1560}