blob: 9336c86d9eb00bd31e63d653504d01aa312e8548 [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"
Kevin Wolf53f76e52010-12-16 15:10:32 +010026#include "qemu-error.h"
aliguorif7b4a942009-01-07 17:40:15 +000027#include "osdep.h"
Jes Sorensendc786bc2010-10-26 10:39:23 +020028#include "sysemu.h"
thsec36ba12007-09-16 21:59:02 +000029#include "block_int.h"
aliguori9230eaf2009-03-28 17:55:19 +000030#include <stdio.h>
bellardea2384d2004-08-01 21:59:26 +000031
bellarde8445332006-06-14 15:32:10 +000032#ifdef _WIN32
33#include <windows.h>
34#endif
35
Anthony Liguoric227f092009-10-01 16:12:16 -050036typedef struct img_cmd_t {
Stuart Brady153859b2009-06-07 00:42:17 +010037 const char *name;
38 int (*handler)(int argc, char **argv);
Anthony Liguoric227f092009-10-01 16:12:16 -050039} img_cmd_t;
Stuart Brady153859b2009-06-07 00:42:17 +010040
aurel32137519c2008-11-30 19:12:49 +000041/* Default to cache=writeback as data integrity is not important for qemu-tcg. */
Stefan Hajnocziadfe0782010-04-13 10:29:35 +010042#define BDRV_O_FLAGS BDRV_O_CACHE_WB
Federico Simoncelli661a0f72011-06-20 12:48:19 -040043#define BDRV_DEFAULT_CACHE "writeback"
aurel32137519c2008-11-30 19:12:49 +000044
bellardea2384d2004-08-01 21:59:26 +000045static void format_print(void *opaque, const char *name)
46{
47 printf(" %s", name);
48}
49
blueswir1d2c639d2009-01-24 18:19:25 +000050/* Please keep in synch with qemu-img.texi */
pbrook3f379ab2007-11-11 03:33:13 +000051static void help(void)
bellardea2384d2004-08-01 21:59:26 +000052{
Paolo Bonzinie00291c2010-02-04 16:49:56 +010053 const char *help_msg =
54 "qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n"
malc3f020d72010-02-08 12:04:56 +030055 "usage: qemu-img command [command options]\n"
56 "QEMU disk image utility\n"
57 "\n"
58 "Command syntax:\n"
Stuart Brady153859b2009-06-07 00:42:17 +010059#define DEF(option, callback, arg_string) \
60 " " arg_string "\n"
61#include "qemu-img-cmds.h"
62#undef DEF
63#undef GEN_DOCS
malc3f020d72010-02-08 12:04:56 +030064 "\n"
65 "Command parameters:\n"
66 " 'filename' is a disk image filename\n"
67 " 'fmt' is the disk image format. It is guessed automatically in most cases\n"
Federico Simoncelli661a0f72011-06-20 12:48:19 -040068 " 'cache' is the cache mode used to write the output disk image, the valid\n"
Liu Yuan80ccf932012-04-20 17:10:56 +080069 " options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n"
70 " 'directsync' and 'unsafe' (default for convert)\n"
malc3f020d72010-02-08 12:04:56 +030071 " 'size' is the disk image size in bytes. Optional suffixes\n"
72 " 'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n"
73 " and T (terabyte, 1024G) are supported. 'b' is ignored.\n"
74 " 'output_filename' is the destination disk image filename\n"
75 " 'output_fmt' is the destination format\n"
76 " 'options' is a comma separated list of format specific options in a\n"
77 " name=value format. Use -o ? for an overview of the options supported by the\n"
78 " used format\n"
79 " '-c' indicates that target image must be compressed (qcow format only)\n"
80 " '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
81 " match exactly. The image doesn't need a working backing file before\n"
82 " rebasing in this case (useful for renaming the backing file)\n"
83 " '-h' with or without a command shows this help and lists the supported formats\n"
Jes Sorensen6b837bc2011-03-30 14:16:25 +020084 " '-p' show progress of command (only certain commands)\n"
Kevin Wolfa22f1232011-08-26 15:27:13 +020085 " '-S' indicates the consecutive number of bytes that must contain only zeros\n"
86 " for qemu-img to create a sparse image during conversion\n"
malc3f020d72010-02-08 12:04:56 +030087 "\n"
Kevin Wolf4534ff52012-05-11 16:07:02 +020088 "Parameters to check subcommand:\n"
89 " '-r' tries to repair any inconsistencies that are found during the check.\n"
90 " '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n"
91 " kinds of errors, with a higher risk of choosing the wrong fix or\n"
92 " hiding corruption that has already occured.\n"
93 "\n"
malc3f020d72010-02-08 12:04:56 +030094 "Parameters to snapshot subcommand:\n"
95 " 'snapshot' is the name of the snapshot to create, apply or delete\n"
96 " '-a' applies a snapshot (revert disk to saved state)\n"
97 " '-c' creates a snapshot\n"
98 " '-d' deletes a snapshot\n"
Paolo Bonzinie00291c2010-02-04 16:49:56 +010099 " '-l' lists all snapshots in the given image\n";
100
101 printf("%s\nSupported formats:", help_msg);
bellardea2384d2004-08-01 21:59:26 +0000102 bdrv_iterate_format(format_print, NULL);
103 printf("\n");
104 exit(1);
105}
106
bellardea2384d2004-08-01 21:59:26 +0000107#if defined(WIN32)
108/* XXX: put correct support for win32 */
109static int read_password(char *buf, int buf_size)
110{
111 int c, i;
112 printf("Password: ");
113 fflush(stdout);
114 i = 0;
115 for(;;) {
116 c = getchar();
117 if (c == '\n')
118 break;
119 if (i < (buf_size - 1))
120 buf[i++] = c;
121 }
122 buf[i] = '\0';
123 return 0;
124}
125
126#else
127
128#include <termios.h>
129
130static struct termios oldtty;
131
132static void term_exit(void)
133{
134 tcsetattr (0, TCSANOW, &oldtty);
135}
136
137static void term_init(void)
138{
139 struct termios tty;
140
141 tcgetattr (0, &tty);
142 oldtty = tty;
143
144 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
145 |INLCR|IGNCR|ICRNL|IXON);
146 tty.c_oflag |= OPOST;
147 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
148 tty.c_cflag &= ~(CSIZE|PARENB);
149 tty.c_cflag |= CS8;
150 tty.c_cc[VMIN] = 1;
151 tty.c_cc[VTIME] = 0;
ths3b46e622007-09-17 08:09:54 +0000152
bellardea2384d2004-08-01 21:59:26 +0000153 tcsetattr (0, TCSANOW, &tty);
154
155 atexit(term_exit);
156}
157
pbrook3f379ab2007-11-11 03:33:13 +0000158static int read_password(char *buf, int buf_size)
bellardea2384d2004-08-01 21:59:26 +0000159{
160 uint8_t ch;
161 int i, ret;
162
163 printf("password: ");
164 fflush(stdout);
165 term_init();
166 i = 0;
167 for(;;) {
168 ret = read(0, &ch, 1);
169 if (ret == -1) {
170 if (errno == EAGAIN || errno == EINTR) {
171 continue;
172 } else {
173 ret = -1;
174 break;
175 }
176 } else if (ret == 0) {
177 ret = -1;
178 break;
179 } else {
180 if (ch == '\r') {
181 ret = 0;
182 break;
183 }
184 if (i < (buf_size - 1))
185 buf[i++] = ch;
186 }
187 }
188 term_exit();
189 buf[i] = '\0';
190 printf("\n");
191 return ret;
192}
193#endif
194
Jes Sorensen4ac8aac2010-12-06 15:25:38 +0100195static int print_block_option_help(const char *filename, const char *fmt)
196{
197 BlockDriver *drv, *proto_drv;
198 QEMUOptionParameter *create_options = NULL;
199
200 /* Find driver and parse its options */
201 drv = bdrv_find_format(fmt);
202 if (!drv) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100203 error_report("Unknown file format '%s'", fmt);
Jes Sorensen4ac8aac2010-12-06 15:25:38 +0100204 return 1;
205 }
206
207 proto_drv = bdrv_find_protocol(filename);
208 if (!proto_drv) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100209 error_report("Unknown protocol '%s'", filename);
Jes Sorensen4ac8aac2010-12-06 15:25:38 +0100210 return 1;
211 }
212
213 create_options = append_option_parameters(create_options,
214 drv->create_options);
215 create_options = append_option_parameters(create_options,
216 proto_drv->create_options);
217 print_option_help(create_options);
218 free_option_parameters(create_options);
219 return 0;
220}
221
bellard75c23802004-08-27 21:28:58 +0000222static BlockDriverState *bdrv_new_open(const char *filename,
Sheng Yang9bc378c2010-01-29 10:15:06 +0800223 const char *fmt,
Stefan Hajnoczif163d072010-04-13 10:29:34 +0100224 int flags)
bellard75c23802004-08-27 21:28:58 +0000225{
226 BlockDriverState *bs;
227 BlockDriver *drv;
228 char password[256];
Kevin Wolfb9eaf9e2011-02-09 11:25:53 +0100229 int ret;
bellard75c23802004-08-27 21:28:58 +0000230
Kevin Wolfb9eaf9e2011-02-09 11:25:53 +0100231 bs = bdrv_new("image");
Kevin Wolfad717132010-12-16 15:37:41 +0100232
bellard75c23802004-08-27 21:28:58 +0000233 if (fmt) {
234 drv = bdrv_find_format(fmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900235 if (!drv) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100236 error_report("Unknown file format '%s'", fmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900237 goto fail;
238 }
bellard75c23802004-08-27 21:28:58 +0000239 } else {
240 drv = NULL;
241 }
Kevin Wolfb9eaf9e2011-02-09 11:25:53 +0100242
243 ret = bdrv_open(bs, filename, flags, drv);
244 if (ret < 0) {
245 error_report("Could not open '%s': %s", filename, strerror(-ret));
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900246 goto fail;
bellard75c23802004-08-27 21:28:58 +0000247 }
Kevin Wolfb9eaf9e2011-02-09 11:25:53 +0100248
bellard75c23802004-08-27 21:28:58 +0000249 if (bdrv_is_encrypted(bs)) {
250 printf("Disk image '%s' is encrypted.\n", filename);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900251 if (read_password(password, sizeof(password)) < 0) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100252 error_report("No password given");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900253 goto fail;
254 }
255 if (bdrv_set_key(bs, password) < 0) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100256 error_report("invalid password");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900257 goto fail;
258 }
bellard75c23802004-08-27 21:28:58 +0000259 }
260 return bs;
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900261fail:
262 if (bs) {
263 bdrv_delete(bs);
264 }
265 return NULL;
bellard75c23802004-08-27 21:28:58 +0000266}
267
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900268static int add_old_style_options(const char *fmt, QEMUOptionParameter *list,
Jes Sorenseneec77d92010-12-07 17:44:34 +0100269 const char *base_filename,
270 const char *base_fmt)
Kevin Wolfefa84d42009-05-18 16:42:12 +0200271{
Kevin Wolfefa84d42009-05-18 16:42:12 +0200272 if (base_filename) {
273 if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100274 error_report("Backing file not supported for file format '%s'",
275 fmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900276 return -1;
Kevin Wolfefa84d42009-05-18 16:42:12 +0200277 }
278 }
279 if (base_fmt) {
280 if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100281 error_report("Backing file format not supported for file "
282 "format '%s'", fmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900283 return -1;
Kevin Wolfefa84d42009-05-18 16:42:12 +0200284 }
285 }
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900286 return 0;
Kevin Wolfefa84d42009-05-18 16:42:12 +0200287}
288
bellardea2384d2004-08-01 21:59:26 +0000289static int img_create(int argc, char **argv)
290{
Jes Sorenseneec77d92010-12-07 17:44:34 +0100291 int c, ret = 0;
Jes Sorensen1da7cfb2010-12-09 14:17:25 +0100292 uint64_t img_size = -1;
bellardea2384d2004-08-01 21:59:26 +0000293 const char *fmt = "raw";
aliguori9230eaf2009-03-28 17:55:19 +0000294 const char *base_fmt = NULL;
bellardea2384d2004-08-01 21:59:26 +0000295 const char *filename;
296 const char *base_filename = NULL;
Kevin Wolf9ea2ea72009-05-18 16:42:11 +0200297 char *options = NULL;
ths3b46e622007-09-17 08:09:54 +0000298
bellardea2384d2004-08-01 21:59:26 +0000299 for(;;) {
Kevin Wolf9ea2ea72009-05-18 16:42:11 +0200300 c = getopt(argc, argv, "F:b:f:he6o:");
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100301 if (c == -1) {
bellardea2384d2004-08-01 21:59:26 +0000302 break;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100303 }
bellardea2384d2004-08-01 21:59:26 +0000304 switch(c) {
Jes Sorensenef873942010-12-06 15:25:40 +0100305 case '?':
bellardea2384d2004-08-01 21:59:26 +0000306 case 'h':
307 help();
308 break;
aliguori9230eaf2009-03-28 17:55:19 +0000309 case 'F':
310 base_fmt = optarg;
311 break;
bellardea2384d2004-08-01 21:59:26 +0000312 case 'b':
313 base_filename = optarg;
314 break;
315 case 'f':
316 fmt = optarg;
317 break;
318 case 'e':
Markus Armbruster9d42e152011-06-22 14:03:55 +0200319 error_report("option -e is deprecated, please use \'-o "
Jes Sorenseneec77d92010-12-07 17:44:34 +0100320 "encryption\' instead!");
321 return 1;
thsd8871c52007-10-24 16:11:42 +0000322 case '6':
Markus Armbruster9d42e152011-06-22 14:03:55 +0200323 error_report("option -6 is deprecated, please use \'-o "
Jes Sorenseneec77d92010-12-07 17:44:34 +0100324 "compat6\' instead!");
325 return 1;
Kevin Wolf9ea2ea72009-05-18 16:42:11 +0200326 case 'o':
327 options = optarg;
328 break;
bellardea2384d2004-08-01 21:59:26 +0000329 }
330 }
aliguori9230eaf2009-03-28 17:55:19 +0000331
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900332 /* Get the filename */
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100333 if (optind >= argc) {
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900334 help();
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100335 }
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900336 filename = argv[optind++];
337
Jes Sorensen1da7cfb2010-12-09 14:17:25 +0100338 /* Get image size, if specified */
339 if (optind < argc) {
Jes Sorensen70b4f4b2011-01-05 11:41:02 +0100340 int64_t sval;
Markus Armbrustere36b3692011-11-22 09:46:05 +0100341 char *end;
342 sval = strtosz_suffix(argv[optind++], &end, STRTOSZ_DEFSUFFIX_B);
343 if (sval < 0 || *end) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100344 error_report("Invalid image size specified! You may use k, M, G or "
Jes Sorensen1da7cfb2010-12-09 14:17:25 +0100345 "T suffixes for ");
Jes Sorensen15654a62010-12-16 14:31:53 +0100346 error_report("kilobytes, megabytes, gigabytes and terabytes.");
Jes Sorensen1da7cfb2010-12-09 14:17:25 +0100347 ret = -1;
348 goto out;
349 }
350 img_size = (uint64_t)sval;
351 }
352
Jes Sorensen4ac8aac2010-12-06 15:25:38 +0100353 if (options && !strcmp(options, "?")) {
354 ret = print_block_option_help(filename, fmt);
355 goto out;
356 }
357
Jes Sorensenf88e1a42010-12-16 13:52:15 +0100358 ret = bdrv_img_create(filename, fmt, base_filename, base_fmt,
359 options, img_size, BDRV_O_FLAGS);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900360out:
361 if (ret) {
362 return 1;
363 }
bellardea2384d2004-08-01 21:59:26 +0000364 return 0;
365}
366
Kevin Wolfe076f332010-06-29 11:43:13 +0200367/*
368 * Checks an image for consistency. Exit codes:
369 *
370 * 0 - Check completed, image is good
371 * 1 - Check not completed because of internal errors
372 * 2 - Check completed, image is corrupted
373 * 3 - Check completed, image has leaked clusters, but is good otherwise
374 */
aliguori15859692009-04-21 23:11:53 +0000375static int img_check(int argc, char **argv)
376{
377 int c, ret;
378 const char *filename, *fmt;
aliguori15859692009-04-21 23:11:53 +0000379 BlockDriverState *bs;
Kevin Wolfe076f332010-06-29 11:43:13 +0200380 BdrvCheckResult result;
Kevin Wolf4534ff52012-05-11 16:07:02 +0200381 int fix = 0;
382 int flags = BDRV_O_FLAGS;
aliguori15859692009-04-21 23:11:53 +0000383
384 fmt = NULL;
385 for(;;) {
Kevin Wolf4534ff52012-05-11 16:07:02 +0200386 c = getopt(argc, argv, "f:hr:");
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100387 if (c == -1) {
aliguori15859692009-04-21 23:11:53 +0000388 break;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100389 }
aliguori15859692009-04-21 23:11:53 +0000390 switch(c) {
Jes Sorensenef873942010-12-06 15:25:40 +0100391 case '?':
aliguori15859692009-04-21 23:11:53 +0000392 case 'h':
393 help();
394 break;
395 case 'f':
396 fmt = optarg;
397 break;
Kevin Wolf4534ff52012-05-11 16:07:02 +0200398 case 'r':
399 flags |= BDRV_O_RDWR;
400
401 if (!strcmp(optarg, "leaks")) {
402 fix = BDRV_FIX_LEAKS;
403 } else if (!strcmp(optarg, "all")) {
404 fix = BDRV_FIX_LEAKS | BDRV_FIX_ERRORS;
405 } else {
406 help();
407 }
408 break;
aliguori15859692009-04-21 23:11:53 +0000409 }
410 }
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100411 if (optind >= argc) {
aliguori15859692009-04-21 23:11:53 +0000412 help();
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100413 }
aliguori15859692009-04-21 23:11:53 +0000414 filename = argv[optind++];
415
Kevin Wolf4534ff52012-05-11 16:07:02 +0200416 bs = bdrv_new_open(filename, fmt, flags);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900417 if (!bs) {
418 return 1;
419 }
Kevin Wolf4534ff52012-05-11 16:07:02 +0200420 ret = bdrv_check(bs, &result, fix);
Kevin Wolfe076f332010-06-29 11:43:13 +0200421
422 if (ret == -ENOTSUP) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100423 error_report("This image format does not support checks");
Kevin Wolfe076f332010-06-29 11:43:13 +0200424 bdrv_delete(bs);
425 return 1;
426 }
427
Kevin Wolfccf34712012-05-11 18:16:54 +0200428 if (result.corruptions_fixed || result.leaks_fixed) {
429 printf("The following inconsistencies were found and repaired:\n\n"
430 " %d leaked clusters\n"
431 " %d corruptions\n\n"
432 "Double checking the fixed image now...\n",
433 result.leaks_fixed,
434 result.corruptions_fixed);
435 ret = bdrv_check(bs, &result, 0);
436 }
437
Kevin Wolfe076f332010-06-29 11:43:13 +0200438 if (!(result.corruptions || result.leaks || result.check_errors)) {
439 printf("No errors were found on the image.\n");
440 } else {
441 if (result.corruptions) {
442 printf("\n%d errors were found on the image.\n"
443 "Data may be corrupted, or further writes to the image "
444 "may corrupt it.\n",
445 result.corruptions);
aliguori15859692009-04-21 23:11:53 +0000446 }
Kevin Wolfe076f332010-06-29 11:43:13 +0200447
448 if (result.leaks) {
449 printf("\n%d leaked clusters were found on the image.\n"
450 "This means waste of disk space, but no harm to data.\n",
451 result.leaks);
452 }
453
454 if (result.check_errors) {
455 printf("\n%d internal errors have occurred during the check.\n",
456 result.check_errors);
457 }
aliguori15859692009-04-21 23:11:53 +0000458 }
459
Dong Xu Wangf8111c22012-03-15 20:13:31 +0800460 if (result.bfi.total_clusters != 0 && result.bfi.allocated_clusters != 0) {
461 printf("%" PRId64 "/%" PRId64 "= %0.2f%% allocated, %0.2f%% fragmented\n",
462 result.bfi.allocated_clusters, result.bfi.total_clusters,
463 result.bfi.allocated_clusters * 100.0 / result.bfi.total_clusters,
464 result.bfi.fragmented_clusters * 100.0 / result.bfi.allocated_clusters);
465 }
466
aliguori15859692009-04-21 23:11:53 +0000467 bdrv_delete(bs);
Kevin Wolfe076f332010-06-29 11:43:13 +0200468
469 if (ret < 0 || result.check_errors) {
470 printf("\nAn error has occurred during the check: %s\n"
471 "The check is not complete and may have missed error.\n",
472 strerror(-ret));
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900473 return 1;
474 }
Kevin Wolfe076f332010-06-29 11:43:13 +0200475
476 if (result.corruptions) {
477 return 2;
478 } else if (result.leaks) {
479 return 3;
480 } else {
481 return 0;
482 }
aliguori15859692009-04-21 23:11:53 +0000483}
484
bellardea2384d2004-08-01 21:59:26 +0000485static int img_commit(int argc, char **argv)
486{
Federico Simoncelli661a0f72011-06-20 12:48:19 -0400487 int c, ret, flags;
488 const char *filename, *fmt, *cache;
bellardea2384d2004-08-01 21:59:26 +0000489 BlockDriverState *bs;
490
491 fmt = NULL;
Federico Simoncelli661a0f72011-06-20 12:48:19 -0400492 cache = BDRV_DEFAULT_CACHE;
bellardea2384d2004-08-01 21:59:26 +0000493 for(;;) {
Federico Simoncelli661a0f72011-06-20 12:48:19 -0400494 c = getopt(argc, argv, "f:ht:");
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100495 if (c == -1) {
bellardea2384d2004-08-01 21:59:26 +0000496 break;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100497 }
bellardea2384d2004-08-01 21:59:26 +0000498 switch(c) {
Jes Sorensenef873942010-12-06 15:25:40 +0100499 case '?':
bellardea2384d2004-08-01 21:59:26 +0000500 case 'h':
501 help();
502 break;
503 case 'f':
504 fmt = optarg;
505 break;
Federico Simoncelli661a0f72011-06-20 12:48:19 -0400506 case 't':
507 cache = optarg;
508 break;
bellardea2384d2004-08-01 21:59:26 +0000509 }
510 }
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100511 if (optind >= argc) {
bellardea2384d2004-08-01 21:59:26 +0000512 help();
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100513 }
bellardea2384d2004-08-01 21:59:26 +0000514 filename = argv[optind++];
515
Federico Simoncelli661a0f72011-06-20 12:48:19 -0400516 flags = BDRV_O_RDWR;
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100517 ret = bdrv_parse_cache_flags(cache, &flags);
Federico Simoncelli661a0f72011-06-20 12:48:19 -0400518 if (ret < 0) {
519 error_report("Invalid cache option: %s", cache);
520 return -1;
521 }
522
523 bs = bdrv_new_open(filename, fmt, flags);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900524 if (!bs) {
525 return 1;
526 }
bellardea2384d2004-08-01 21:59:26 +0000527 ret = bdrv_commit(bs);
528 switch(ret) {
529 case 0:
530 printf("Image committed.\n");
531 break;
532 case -ENOENT:
Jes Sorensen15654a62010-12-16 14:31:53 +0100533 error_report("No disk inserted");
bellardea2384d2004-08-01 21:59:26 +0000534 break;
535 case -EACCES:
Jes Sorensen15654a62010-12-16 14:31:53 +0100536 error_report("Image is read-only");
bellardea2384d2004-08-01 21:59:26 +0000537 break;
538 case -ENOTSUP:
Jes Sorensen15654a62010-12-16 14:31:53 +0100539 error_report("Image is already committed");
bellardea2384d2004-08-01 21:59:26 +0000540 break;
541 default:
Jes Sorensen15654a62010-12-16 14:31:53 +0100542 error_report("Error while committing image");
bellardea2384d2004-08-01 21:59:26 +0000543 break;
544 }
545
546 bdrv_delete(bs);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900547 if (ret) {
548 return 1;
549 }
bellardea2384d2004-08-01 21:59:26 +0000550 return 0;
551}
552
Dmitry Konishchevf6a00aa2011-05-18 15:03:59 +0400553/*
thsf58c7b32008-06-05 21:53:49 +0000554 * Returns true iff the first sector pointed to by 'buf' contains at least
555 * a non-NUL byte.
556 *
557 * 'pnum' is set to the number of sectors (including and immediately following
558 * the first one) that are known to be in the same allocated/unallocated state.
559 */
bellardea2384d2004-08-01 21:59:26 +0000560static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
561{
Stefan Hajnoczi1a6d39f2012-02-07 13:27:24 +0000562 bool is_zero;
563 int i;
bellardea2384d2004-08-01 21:59:26 +0000564
565 if (n <= 0) {
566 *pnum = 0;
567 return 0;
568 }
Stefan Hajnoczi1a6d39f2012-02-07 13:27:24 +0000569 is_zero = buffer_is_zero(buf, 512);
bellardea2384d2004-08-01 21:59:26 +0000570 for(i = 1; i < n; i++) {
571 buf += 512;
Stefan Hajnoczi1a6d39f2012-02-07 13:27:24 +0000572 if (is_zero != buffer_is_zero(buf, 512)) {
bellardea2384d2004-08-01 21:59:26 +0000573 break;
Stefan Hajnoczi1a6d39f2012-02-07 13:27:24 +0000574 }
bellardea2384d2004-08-01 21:59:26 +0000575 }
576 *pnum = i;
Stefan Hajnoczi1a6d39f2012-02-07 13:27:24 +0000577 return !is_zero;
bellardea2384d2004-08-01 21:59:26 +0000578}
579
Kevin Wolf3e85c6f2010-01-12 12:55:18 +0100580/*
Kevin Wolfa22f1232011-08-26 15:27:13 +0200581 * Like is_allocated_sectors, but if the buffer starts with a used sector,
582 * up to 'min' consecutive sectors containing zeros are ignored. This avoids
583 * breaking up write requests for only small sparse areas.
584 */
585static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
586 int min)
587{
588 int ret;
589 int num_checked, num_used;
590
591 if (n < min) {
592 min = n;
593 }
594
595 ret = is_allocated_sectors(buf, n, pnum);
596 if (!ret) {
597 return ret;
598 }
599
600 num_used = *pnum;
601 buf += BDRV_SECTOR_SIZE * *pnum;
602 n -= *pnum;
603 num_checked = num_used;
604
605 while (n > 0) {
606 ret = is_allocated_sectors(buf, n, pnum);
607
608 buf += BDRV_SECTOR_SIZE * *pnum;
609 n -= *pnum;
610 num_checked += *pnum;
611 if (ret) {
612 num_used = num_checked;
613 } else if (*pnum >= min) {
614 break;
615 }
616 }
617
618 *pnum = num_used;
619 return 1;
620}
621
622/*
Kevin Wolf3e85c6f2010-01-12 12:55:18 +0100623 * Compares two buffers sector by sector. Returns 0 if the first sector of both
624 * buffers matches, non-zero otherwise.
625 *
626 * pnum is set to the number of sectors (including and immediately following
627 * the first one) that are known to have the same comparison result
628 */
629static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
630 int *pnum)
631{
632 int res, i;
633
634 if (n <= 0) {
635 *pnum = 0;
636 return 0;
637 }
638
639 res = !!memcmp(buf1, buf2, 512);
640 for(i = 1; i < n; i++) {
641 buf1 += 512;
642 buf2 += 512;
643
644 if (!!memcmp(buf1, buf2, 512) != res) {
645 break;
646 }
647 }
648
649 *pnum = i;
650 return res;
651}
652
Kevin Wolf80ee15a2009-09-15 12:30:43 +0200653#define IO_BUF_SIZE (2 * 1024 * 1024)
bellardea2384d2004-08-01 21:59:26 +0000654
655static int img_convert(int argc, char **argv)
656{
Jes Sorenseneec77d92010-12-07 17:44:34 +0100657 int c, ret = 0, n, n1, bs_n, bs_i, compress, cluster_size, cluster_sectors;
Federico Simoncelli661a0f72011-06-20 12:48:19 -0400658 int progress = 0, flags;
659 const char *fmt, *out_fmt, *cache, *out_baseimg, *out_filename;
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900660 BlockDriver *drv, *proto_drv;
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900661 BlockDriverState **bs = NULL, *out_bs = NULL;
ths96b8f132007-12-17 01:35:20 +0000662 int64_t total_sectors, nb_sectors, sector_num, bs_offset;
663 uint64_t bs_sectors;
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900664 uint8_t * buf = NULL;
bellardea2384d2004-08-01 21:59:26 +0000665 const uint8_t *buf1;
bellardfaea38e2006-08-05 21:31:00 +0000666 BlockDriverInfo bdi;
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900667 QEMUOptionParameter *param = NULL, *create_options = NULL;
Kevin Wolfa18953f2010-10-14 15:46:04 +0200668 QEMUOptionParameter *out_baseimg_param;
Kevin Wolfefa84d42009-05-18 16:42:12 +0200669 char *options = NULL;
edison51ef6722010-09-21 19:58:41 -0700670 const char *snapshot_name = NULL;
Jes Sorensen6b837bc2011-03-30 14:16:25 +0200671 float local_progress;
Kevin Wolfa22f1232011-08-26 15:27:13 +0200672 int min_sparse = 8; /* Need at least 4k of zeros for sparse detection */
bellardea2384d2004-08-01 21:59:26 +0000673
674 fmt = NULL;
675 out_fmt = "raw";
Federico Simoncelli661a0f72011-06-20 12:48:19 -0400676 cache = "unsafe";
thsf58c7b32008-06-05 21:53:49 +0000677 out_baseimg = NULL;
Jes Sorenseneec77d92010-12-07 17:44:34 +0100678 compress = 0;
bellardea2384d2004-08-01 21:59:26 +0000679 for(;;) {
Kevin Wolfa22f1232011-08-26 15:27:13 +0200680 c = getopt(argc, argv, "f:O:B:s:hce6o:pS:t:");
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100681 if (c == -1) {
bellardea2384d2004-08-01 21:59:26 +0000682 break;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100683 }
bellardea2384d2004-08-01 21:59:26 +0000684 switch(c) {
Jes Sorensenef873942010-12-06 15:25:40 +0100685 case '?':
bellardea2384d2004-08-01 21:59:26 +0000686 case 'h':
687 help();
688 break;
689 case 'f':
690 fmt = optarg;
691 break;
692 case 'O':
693 out_fmt = optarg;
694 break;
thsf58c7b32008-06-05 21:53:49 +0000695 case 'B':
696 out_baseimg = optarg;
697 break;
bellardea2384d2004-08-01 21:59:26 +0000698 case 'c':
Jes Sorenseneec77d92010-12-07 17:44:34 +0100699 compress = 1;
bellardea2384d2004-08-01 21:59:26 +0000700 break;
701 case 'e':
Markus Armbruster9d42e152011-06-22 14:03:55 +0200702 error_report("option -e is deprecated, please use \'-o "
Jes Sorenseneec77d92010-12-07 17:44:34 +0100703 "encryption\' instead!");
704 return 1;
thsec36ba12007-09-16 21:59:02 +0000705 case '6':
Markus Armbruster9d42e152011-06-22 14:03:55 +0200706 error_report("option -6 is deprecated, please use \'-o "
Jes Sorenseneec77d92010-12-07 17:44:34 +0100707 "compat6\' instead!");
708 return 1;
Kevin Wolfefa84d42009-05-18 16:42:12 +0200709 case 'o':
710 options = optarg;
711 break;
edison51ef6722010-09-21 19:58:41 -0700712 case 's':
713 snapshot_name = optarg;
714 break;
Kevin Wolfa22f1232011-08-26 15:27:13 +0200715 case 'S':
716 {
717 int64_t sval;
Markus Armbrustere36b3692011-11-22 09:46:05 +0100718 char *end;
719 sval = strtosz_suffix(optarg, &end, STRTOSZ_DEFSUFFIX_B);
720 if (sval < 0 || *end) {
Kevin Wolfa22f1232011-08-26 15:27:13 +0200721 error_report("Invalid minimum zero buffer size for sparse output specified");
722 return 1;
723 }
724
725 min_sparse = sval / BDRV_SECTOR_SIZE;
726 break;
727 }
Jes Sorensen6b837bc2011-03-30 14:16:25 +0200728 case 'p':
729 progress = 1;
730 break;
Federico Simoncelli661a0f72011-06-20 12:48:19 -0400731 case 't':
732 cache = optarg;
733 break;
bellardea2384d2004-08-01 21:59:26 +0000734 }
735 }
ths3b46e622007-09-17 08:09:54 +0000736
balrog926c2d22007-10-31 01:11:44 +0000737 bs_n = argc - optind - 1;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100738 if (bs_n < 1) {
739 help();
740 }
balrog926c2d22007-10-31 01:11:44 +0000741
742 out_filename = argv[argc - 1];
thsf58c7b32008-06-05 21:53:49 +0000743
Charles Arnoldfa170c12012-05-11 10:57:54 -0600744 /* Initialize before goto out */
745 qemu_progress_init(progress, 2.0);
746
Jes Sorensen4ac8aac2010-12-06 15:25:38 +0100747 if (options && !strcmp(options, "?")) {
748 ret = print_block_option_help(out_filename, out_fmt);
749 goto out;
750 }
751
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900752 if (bs_n > 1 && out_baseimg) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100753 error_report("-B makes no sense when concatenating multiple input "
754 "images");
Jes Sorensen31ca34b2010-12-06 15:25:36 +0100755 ret = -1;
756 goto out;
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900757 }
Dong Xu Wangf8111c22012-03-15 20:13:31 +0800758
Jes Sorensen6b837bc2011-03-30 14:16:25 +0200759 qemu_progress_print(0, 100);
760
Anthony Liguori7267c092011-08-20 22:09:37 -0500761 bs = g_malloc0(bs_n * sizeof(BlockDriverState *));
balrog926c2d22007-10-31 01:11:44 +0000762
763 total_sectors = 0;
764 for (bs_i = 0; bs_i < bs_n; bs_i++) {
Stefan Hajnocziadfe0782010-04-13 10:29:35 +0100765 bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, BDRV_O_FLAGS);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900766 if (!bs[bs_i]) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100767 error_report("Could not open '%s'", argv[optind + bs_i]);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900768 ret = -1;
769 goto out;
770 }
balrog926c2d22007-10-31 01:11:44 +0000771 bdrv_get_geometry(bs[bs_i], &bs_sectors);
772 total_sectors += bs_sectors;
773 }
bellardea2384d2004-08-01 21:59:26 +0000774
edison51ef6722010-09-21 19:58:41 -0700775 if (snapshot_name != NULL) {
776 if (bs_n > 1) {
Markus Armbruster6daf1942011-06-22 14:03:54 +0200777 error_report("No support for concatenating multiple snapshot");
edison51ef6722010-09-21 19:58:41 -0700778 ret = -1;
779 goto out;
780 }
781 if (bdrv_snapshot_load_tmp(bs[0], snapshot_name) < 0) {
Markus Armbruster6daf1942011-06-22 14:03:54 +0200782 error_report("Failed to load snapshot");
edison51ef6722010-09-21 19:58:41 -0700783 ret = -1;
784 goto out;
785 }
786 }
787
Kevin Wolfefa84d42009-05-18 16:42:12 +0200788 /* Find driver and parse its options */
bellardea2384d2004-08-01 21:59:26 +0000789 drv = bdrv_find_format(out_fmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900790 if (!drv) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100791 error_report("Unknown file format '%s'", out_fmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900792 ret = -1;
793 goto out;
794 }
balrog926c2d22007-10-31 01:11:44 +0000795
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900796 proto_drv = bdrv_find_protocol(out_filename);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900797 if (!proto_drv) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100798 error_report("Unknown protocol '%s'", out_filename);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900799 ret = -1;
800 goto out;
801 }
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900802
803 create_options = append_option_parameters(create_options,
804 drv->create_options);
805 create_options = append_option_parameters(create_options,
806 proto_drv->create_options);
Kevin Wolfdb08adf2009-06-04 15:39:38 +0200807
Kevin Wolfefa84d42009-05-18 16:42:12 +0200808 if (options) {
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900809 param = parse_option_parameters(options, create_options, param);
Kevin Wolfefa84d42009-05-18 16:42:12 +0200810 if (param == NULL) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100811 error_report("Invalid options for file format '%s'.", out_fmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900812 ret = -1;
813 goto out;
Kevin Wolfefa84d42009-05-18 16:42:12 +0200814 }
815 } else {
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900816 param = parse_option_parameters("", create_options, param);
Kevin Wolfefa84d42009-05-18 16:42:12 +0200817 }
818
819 set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
Jes Sorenseneec77d92010-12-07 17:44:34 +0100820 ret = add_old_style_options(out_fmt, param, out_baseimg, NULL);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900821 if (ret < 0) {
822 goto out;
823 }
Kevin Wolfefa84d42009-05-18 16:42:12 +0200824
Kevin Wolfa18953f2010-10-14 15:46:04 +0200825 /* Get backing file name if -o backing_file was used */
826 out_baseimg_param = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
827 if (out_baseimg_param) {
828 out_baseimg = out_baseimg_param->value.s;
829 }
830
Kevin Wolfefa84d42009-05-18 16:42:12 +0200831 /* Check if compression is supported */
Jes Sorenseneec77d92010-12-07 17:44:34 +0100832 if (compress) {
Kevin Wolfefa84d42009-05-18 16:42:12 +0200833 QEMUOptionParameter *encryption =
834 get_option_parameter(param, BLOCK_OPT_ENCRYPT);
Kevin Wolf41521fa2011-10-18 16:19:42 +0200835 QEMUOptionParameter *preallocation =
836 get_option_parameter(param, BLOCK_OPT_PREALLOC);
Kevin Wolfefa84d42009-05-18 16:42:12 +0200837
838 if (!drv->bdrv_write_compressed) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100839 error_report("Compression not supported for this file format");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900840 ret = -1;
841 goto out;
Kevin Wolfefa84d42009-05-18 16:42:12 +0200842 }
843
844 if (encryption && encryption->value.n) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100845 error_report("Compression and encryption not supported at "
846 "the same time");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900847 ret = -1;
848 goto out;
Kevin Wolfefa84d42009-05-18 16:42:12 +0200849 }
Kevin Wolf41521fa2011-10-18 16:19:42 +0200850
851 if (preallocation && preallocation->value.s
852 && strcmp(preallocation->value.s, "off"))
853 {
854 error_report("Compression and preallocation not supported at "
855 "the same time");
856 ret = -1;
857 goto out;
858 }
Kevin Wolfefa84d42009-05-18 16:42:12 +0200859 }
860
861 /* Create the new image */
862 ret = bdrv_create(drv, out_filename, param);
bellardea2384d2004-08-01 21:59:26 +0000863 if (ret < 0) {
864 if (ret == -ENOTSUP) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100865 error_report("Formatting not supported for file format '%s'",
866 out_fmt);
aurel326e9ea0c2009-04-15 14:42:46 +0000867 } else if (ret == -EFBIG) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100868 error_report("The image size is too large for file format '%s'",
869 out_fmt);
bellardea2384d2004-08-01 21:59:26 +0000870 } else {
Jes Sorensen15654a62010-12-16 14:31:53 +0100871 error_report("%s: error while converting %s: %s",
872 out_filename, out_fmt, strerror(-ret));
bellardea2384d2004-08-01 21:59:26 +0000873 }
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900874 goto out;
bellardea2384d2004-08-01 21:59:26 +0000875 }
ths3b46e622007-09-17 08:09:54 +0000876
Federico Simoncelli661a0f72011-06-20 12:48:19 -0400877 flags = BDRV_O_RDWR;
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100878 ret = bdrv_parse_cache_flags(cache, &flags);
Federico Simoncelli661a0f72011-06-20 12:48:19 -0400879 if (ret < 0) {
880 error_report("Invalid cache option: %s", cache);
881 return -1;
882 }
883
884 out_bs = bdrv_new_open(out_filename, out_fmt, flags);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900885 if (!out_bs) {
886 ret = -1;
887 goto out;
888 }
bellardea2384d2004-08-01 21:59:26 +0000889
balrog926c2d22007-10-31 01:11:44 +0000890 bs_i = 0;
891 bs_offset = 0;
892 bdrv_get_geometry(bs[0], &bs_sectors);
Kevin Wolfbb1c0592011-08-08 14:09:12 +0200893 buf = qemu_blockalign(out_bs, IO_BUF_SIZE);
balrog926c2d22007-10-31 01:11:44 +0000894
Jes Sorenseneec77d92010-12-07 17:44:34 +0100895 if (compress) {
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900896 ret = bdrv_get_info(out_bs, &bdi);
897 if (ret < 0) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100898 error_report("could not get block driver info");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900899 goto out;
900 }
bellardfaea38e2006-08-05 21:31:00 +0000901 cluster_size = bdi.cluster_size;
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900902 if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100903 error_report("invalid cluster size");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900904 ret = -1;
905 goto out;
906 }
bellardea2384d2004-08-01 21:59:26 +0000907 cluster_sectors = cluster_size >> 9;
908 sector_num = 0;
Jes Sorensen6b837bc2011-03-30 14:16:25 +0200909
910 nb_sectors = total_sectors;
911 local_progress = (float)100 /
Jes Sorensen4ee96412011-05-06 11:39:11 +0200912 (nb_sectors / MIN(nb_sectors, cluster_sectors));
Jes Sorensen6b837bc2011-03-30 14:16:25 +0200913
bellardea2384d2004-08-01 21:59:26 +0000914 for(;;) {
balrog926c2d22007-10-31 01:11:44 +0000915 int64_t bs_num;
916 int remainder;
917 uint8_t *buf2;
918
bellardea2384d2004-08-01 21:59:26 +0000919 nb_sectors = total_sectors - sector_num;
920 if (nb_sectors <= 0)
921 break;
922 if (nb_sectors >= cluster_sectors)
923 n = cluster_sectors;
924 else
925 n = nb_sectors;
balrog926c2d22007-10-31 01:11:44 +0000926
927 bs_num = sector_num - bs_offset;
928 assert (bs_num >= 0);
929 remainder = n;
930 buf2 = buf;
931 while (remainder > 0) {
932 int nlow;
933 while (bs_num == bs_sectors) {
934 bs_i++;
935 assert (bs_i < bs_n);
936 bs_offset += bs_sectors;
937 bdrv_get_geometry(bs[bs_i], &bs_sectors);
938 bs_num = 0;
Blue Swirl0bfcd592010-05-22 08:02:12 +0000939 /* printf("changing part: sector_num=%" PRId64 ", "
940 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
941 "\n", sector_num, bs_i, bs_offset, bs_sectors); */
balrog926c2d22007-10-31 01:11:44 +0000942 }
943 assert (bs_num < bs_sectors);
944
945 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;
946
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900947 ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow);
948 if (ret < 0) {
Stefan Hajnoczi3fba9d82011-08-17 17:41:09 +0100949 error_report("error while reading sector %" PRId64 ": %s",
950 bs_num, strerror(-ret));
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900951 goto out;
952 }
balrog926c2d22007-10-31 01:11:44 +0000953
954 buf2 += nlow * 512;
955 bs_num += nlow;
956
957 remainder -= nlow;
958 }
959 assert (remainder == 0);
960
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100961 if (n < cluster_sectors) {
bellardea2384d2004-08-01 21:59:26 +0000962 memset(buf + n * 512, 0, cluster_size - n * 512);
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100963 }
Stefan Hajnoczi1a6d39f2012-02-07 13:27:24 +0000964 if (!buffer_is_zero(buf, cluster_size)) {
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900965 ret = bdrv_write_compressed(out_bs, sector_num, buf,
966 cluster_sectors);
967 if (ret != 0) {
Stefan Hajnoczi3fba9d82011-08-17 17:41:09 +0100968 error_report("error while compressing sector %" PRId64
969 ": %s", sector_num, strerror(-ret));
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900970 goto out;
971 }
bellardea2384d2004-08-01 21:59:26 +0000972 }
973 sector_num += n;
Jes Sorensen6b837bc2011-03-30 14:16:25 +0200974 qemu_progress_print(local_progress, 100);
bellardea2384d2004-08-01 21:59:26 +0000975 }
bellardfaea38e2006-08-05 21:31:00 +0000976 /* signal EOF to align */
977 bdrv_write_compressed(out_bs, 0, NULL, 0);
bellardea2384d2004-08-01 21:59:26 +0000978 } else {
Kevin Wolff2feebb2010-04-14 17:30:35 +0200979 int has_zero_init = bdrv_has_zero_init(out_bs);
980
thsf58c7b32008-06-05 21:53:49 +0000981 sector_num = 0; // total number of sectors converted so far
Jes Sorensen6b837bc2011-03-30 14:16:25 +0200982 nb_sectors = total_sectors - sector_num;
983 local_progress = (float)100 /
Jes Sorensen4ee96412011-05-06 11:39:11 +0200984 (nb_sectors / MIN(nb_sectors, IO_BUF_SIZE / 512));
Jes Sorensen6b837bc2011-03-30 14:16:25 +0200985
bellardea2384d2004-08-01 21:59:26 +0000986 for(;;) {
987 nb_sectors = total_sectors - sector_num;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100988 if (nb_sectors <= 0) {
bellardea2384d2004-08-01 21:59:26 +0000989 break;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100990 }
991 if (nb_sectors >= (IO_BUF_SIZE / 512)) {
bellardea2384d2004-08-01 21:59:26 +0000992 n = (IO_BUF_SIZE / 512);
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100993 } else {
bellardea2384d2004-08-01 21:59:26 +0000994 n = nb_sectors;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100995 }
balrog926c2d22007-10-31 01:11:44 +0000996
997 while (sector_num - bs_offset >= bs_sectors) {
998 bs_i ++;
999 assert (bs_i < bs_n);
1000 bs_offset += bs_sectors;
1001 bdrv_get_geometry(bs[bs_i], &bs_sectors);
Blue Swirl0bfcd592010-05-22 08:02:12 +00001002 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
1003 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
balrog926c2d22007-10-31 01:11:44 +00001004 sector_num, bs_i, bs_offset, bs_sectors); */
1005 }
1006
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001007 if (n > bs_offset + bs_sectors - sector_num) {
balrog926c2d22007-10-31 01:11:44 +00001008 n = bs_offset + bs_sectors - sector_num;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001009 }
balrog926c2d22007-10-31 01:11:44 +00001010
Kevin Wolff2feebb2010-04-14 17:30:35 +02001011 if (has_zero_init) {
Akkarit Sangpetchd0320442009-07-17 10:02:15 +02001012 /* If the output image is being created as a copy on write image,
1013 assume that sectors which are unallocated in the input image
1014 are present in both the output's and input's base images (no
1015 need to copy them). */
1016 if (out_baseimg) {
1017 if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
1018 n, &n1)) {
1019 sector_num += n1;
1020 continue;
1021 }
1022 /* The next 'n1' sectors are allocated in the input image. Copy
1023 only those as they may be followed by unallocated sectors. */
1024 n = n1;
aliguori93c65b42009-04-05 17:40:43 +00001025 }
aliguori93c65b42009-04-05 17:40:43 +00001026 } else {
1027 n1 = n;
thsf58c7b32008-06-05 21:53:49 +00001028 }
1029
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001030 ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
1031 if (ret < 0) {
Stefan Hajnoczi3fba9d82011-08-17 17:41:09 +01001032 error_report("error while reading sector %" PRId64 ": %s",
1033 sector_num - bs_offset, strerror(-ret));
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001034 goto out;
1035 }
bellardea2384d2004-08-01 21:59:26 +00001036 /* NOTE: at the same time we convert, we do not write zero
1037 sectors to have a chance to compress the image. Ideally, we
1038 should add a specific call to have the info to go faster */
1039 buf1 = buf;
1040 while (n > 0) {
thsf58c7b32008-06-05 21:53:49 +00001041 /* If the output image is being created as a copy on write image,
1042 copy all sectors even the ones containing only NUL bytes,
aliguori93c65b42009-04-05 17:40:43 +00001043 because they may differ from the sectors in the base image.
1044
1045 If the output is to a host device, we also write out
1046 sectors that are entirely 0, since whatever data was
1047 already there is garbage, not 0s. */
Kevin Wolff2feebb2010-04-14 17:30:35 +02001048 if (!has_zero_init || out_baseimg ||
Kevin Wolfa22f1232011-08-26 15:27:13 +02001049 is_allocated_sectors_min(buf1, n, &n1, min_sparse)) {
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001050 ret = bdrv_write(out_bs, sector_num, buf1, n1);
1051 if (ret < 0) {
Stefan Hajnoczi3fba9d82011-08-17 17:41:09 +01001052 error_report("error while writing sector %" PRId64
1053 ": %s", sector_num, strerror(-ret));
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001054 goto out;
1055 }
bellardea2384d2004-08-01 21:59:26 +00001056 }
1057 sector_num += n1;
1058 n -= n1;
1059 buf1 += n1 * 512;
1060 }
Jes Sorensen6b837bc2011-03-30 14:16:25 +02001061 qemu_progress_print(local_progress, 100);
bellardea2384d2004-08-01 21:59:26 +00001062 }
1063 }
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001064out:
Jes Sorensen6b837bc2011-03-30 14:16:25 +02001065 qemu_progress_end();
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001066 free_option_parameters(create_options);
1067 free_option_parameters(param);
Kevin Wolfbb1c0592011-08-08 14:09:12 +02001068 qemu_vfree(buf);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001069 if (out_bs) {
1070 bdrv_delete(out_bs);
1071 }
Jes Sorensen31ca34b2010-12-06 15:25:36 +01001072 if (bs) {
1073 for (bs_i = 0; bs_i < bs_n; bs_i++) {
1074 if (bs[bs_i]) {
1075 bdrv_delete(bs[bs_i]);
1076 }
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001077 }
Anthony Liguori7267c092011-08-20 22:09:37 -05001078 g_free(bs);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001079 }
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001080 if (ret) {
1081 return 1;
1082 }
bellardea2384d2004-08-01 21:59:26 +00001083 return 0;
1084}
1085
bellard57d1a2b2004-08-03 21:15:11 +00001086
bellardfaea38e2006-08-05 21:31:00 +00001087static void dump_snapshots(BlockDriverState *bs)
1088{
1089 QEMUSnapshotInfo *sn_tab, *sn;
1090 int nb_sns, i;
1091 char buf[256];
1092
1093 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1094 if (nb_sns <= 0)
1095 return;
1096 printf("Snapshot list:\n");
1097 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
1098 for(i = 0; i < nb_sns; i++) {
1099 sn = &sn_tab[i];
1100 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
1101 }
Anthony Liguori7267c092011-08-20 22:09:37 -05001102 g_free(sn_tab);
bellardfaea38e2006-08-05 21:31:00 +00001103}
1104
bellardea2384d2004-08-01 21:59:26 +00001105static int img_info(int argc, char **argv)
1106{
1107 int c;
1108 const char *filename, *fmt;
bellardea2384d2004-08-01 21:59:26 +00001109 BlockDriverState *bs;
1110 char fmt_name[128], size_buf[128], dsize_buf[128];
ths96b8f132007-12-17 01:35:20 +00001111 uint64_t total_sectors;
1112 int64_t allocated_size;
bellard93b6b2a2006-08-01 15:51:11 +00001113 char backing_filename[1024];
1114 char backing_filename2[1024];
bellardfaea38e2006-08-05 21:31:00 +00001115 BlockDriverInfo bdi;
bellardea2384d2004-08-01 21:59:26 +00001116
1117 fmt = NULL;
1118 for(;;) {
1119 c = getopt(argc, argv, "f:h");
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001120 if (c == -1) {
bellardea2384d2004-08-01 21:59:26 +00001121 break;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001122 }
bellardea2384d2004-08-01 21:59:26 +00001123 switch(c) {
Jes Sorensenef873942010-12-06 15:25:40 +01001124 case '?':
bellardea2384d2004-08-01 21:59:26 +00001125 case 'h':
1126 help();
1127 break;
1128 case 'f':
1129 fmt = optarg;
1130 break;
1131 }
1132 }
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001133 if (optind >= argc) {
bellardea2384d2004-08-01 21:59:26 +00001134 help();
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001135 }
bellardea2384d2004-08-01 21:59:26 +00001136 filename = argv[optind++];
1137
Stefan Hajnocziadfe0782010-04-13 10:29:35 +01001138 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001139 if (!bs) {
1140 return 1;
1141 }
bellardea2384d2004-08-01 21:59:26 +00001142 bdrv_get_format(bs, fmt_name, sizeof(fmt_name));
1143 bdrv_get_geometry(bs, &total_sectors);
1144 get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512);
Fam Zheng4a1d5e12011-07-12 19:56:39 +08001145 allocated_size = bdrv_get_allocated_file_size(bs);
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001146 if (allocated_size < 0) {
blueswir1a10ea302008-08-24 10:30:33 +00001147 snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001148 } else {
ths5fafdf22007-09-16 21:08:06 +00001149 get_human_readable_size(dsize_buf, sizeof(dsize_buf),
bellardde167e42005-04-28 21:15:08 +00001150 allocated_size);
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001151 }
bellardea2384d2004-08-01 21:59:26 +00001152 printf("image: %s\n"
1153 "file format: %s\n"
bellardec3757d2006-06-14 15:50:07 +00001154 "virtual size: %s (%" PRId64 " bytes)\n"
bellardea2384d2004-08-01 21:59:26 +00001155 "disk size: %s\n",
ths5fafdf22007-09-16 21:08:06 +00001156 filename, fmt_name, size_buf,
bellardec3757d2006-06-14 15:50:07 +00001157 (total_sectors * 512),
bellardea2384d2004-08-01 21:59:26 +00001158 dsize_buf);
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001159 if (bdrv_is_encrypted(bs)) {
bellardea2384d2004-08-01 21:59:26 +00001160 printf("encrypted: yes\n");
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001161 }
bellardfaea38e2006-08-05 21:31:00 +00001162 if (bdrv_get_info(bs, &bdi) >= 0) {
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001163 if (bdi.cluster_size != 0) {
bellardfaea38e2006-08-05 21:31:00 +00001164 printf("cluster_size: %d\n", bdi.cluster_size);
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001165 }
Dong Xu Wang64c79162012-03-15 20:13:33 +08001166 if (bdi.is_dirty) {
1167 printf("cleanly shut down: no\n");
1168 }
bellardfaea38e2006-08-05 21:31:00 +00001169 }
bellard93b6b2a2006-08-01 15:51:11 +00001170 bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
bellardfaea38e2006-08-05 21:31:00 +00001171 if (backing_filename[0] != '\0') {
Paolo Bonzinidc5a1372012-05-08 16:51:50 +02001172 bdrv_get_full_backing_filename(bs, backing_filename2,
1173 sizeof(backing_filename2));
1174 printf("backing file: %s", backing_filename);
1175 if (strcmp(backing_filename, backing_filename2) != 0) {
1176 printf(" (actual path: %s)", backing_filename2);
1177 }
1178 putchar('\n');
bellardfaea38e2006-08-05 21:31:00 +00001179 }
1180 dump_snapshots(bs);
bellardea2384d2004-08-01 21:59:26 +00001181 bdrv_delete(bs);
1182 return 0;
1183}
1184
aliguorif7b4a942009-01-07 17:40:15 +00001185#define SNAPSHOT_LIST 1
1186#define SNAPSHOT_CREATE 2
1187#define SNAPSHOT_APPLY 3
1188#define SNAPSHOT_DELETE 4
1189
Stuart Brady153859b2009-06-07 00:42:17 +01001190static int img_snapshot(int argc, char **argv)
aliguorif7b4a942009-01-07 17:40:15 +00001191{
1192 BlockDriverState *bs;
1193 QEMUSnapshotInfo sn;
1194 char *filename, *snapshot_name = NULL;
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001195 int c, ret = 0, bdrv_oflags;
aliguorif7b4a942009-01-07 17:40:15 +00001196 int action = 0;
1197 qemu_timeval tv;
1198
Kevin Wolf710da702011-01-10 12:33:02 +01001199 bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
aliguorif7b4a942009-01-07 17:40:15 +00001200 /* Parse commandline parameters */
1201 for(;;) {
1202 c = getopt(argc, argv, "la:c:d:h");
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001203 if (c == -1) {
aliguorif7b4a942009-01-07 17:40:15 +00001204 break;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001205 }
aliguorif7b4a942009-01-07 17:40:15 +00001206 switch(c) {
Jes Sorensenef873942010-12-06 15:25:40 +01001207 case '?':
aliguorif7b4a942009-01-07 17:40:15 +00001208 case 'h':
1209 help();
Stuart Brady153859b2009-06-07 00:42:17 +01001210 return 0;
aliguorif7b4a942009-01-07 17:40:15 +00001211 case 'l':
1212 if (action) {
1213 help();
Stuart Brady153859b2009-06-07 00:42:17 +01001214 return 0;
aliguorif7b4a942009-01-07 17:40:15 +00001215 }
1216 action = SNAPSHOT_LIST;
Naphtali Spreif5edb012010-01-17 16:48:13 +02001217 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
aliguorif7b4a942009-01-07 17:40:15 +00001218 break;
1219 case 'a':
1220 if (action) {
1221 help();
Stuart Brady153859b2009-06-07 00:42:17 +01001222 return 0;
aliguorif7b4a942009-01-07 17:40:15 +00001223 }
1224 action = SNAPSHOT_APPLY;
1225 snapshot_name = optarg;
1226 break;
1227 case 'c':
1228 if (action) {
1229 help();
Stuart Brady153859b2009-06-07 00:42:17 +01001230 return 0;
aliguorif7b4a942009-01-07 17:40:15 +00001231 }
1232 action = SNAPSHOT_CREATE;
1233 snapshot_name = optarg;
1234 break;
1235 case 'd':
1236 if (action) {
1237 help();
Stuart Brady153859b2009-06-07 00:42:17 +01001238 return 0;
aliguorif7b4a942009-01-07 17:40:15 +00001239 }
1240 action = SNAPSHOT_DELETE;
1241 snapshot_name = optarg;
1242 break;
1243 }
1244 }
1245
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001246 if (optind >= argc) {
aliguorif7b4a942009-01-07 17:40:15 +00001247 help();
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001248 }
aliguorif7b4a942009-01-07 17:40:15 +00001249 filename = argv[optind++];
1250
1251 /* Open the image */
Stefan Hajnoczif163d072010-04-13 10:29:34 +01001252 bs = bdrv_new_open(filename, NULL, bdrv_oflags);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001253 if (!bs) {
1254 return 1;
1255 }
aliguorif7b4a942009-01-07 17:40:15 +00001256
1257 /* Perform the requested action */
1258 switch(action) {
1259 case SNAPSHOT_LIST:
1260 dump_snapshots(bs);
1261 break;
1262
1263 case SNAPSHOT_CREATE:
1264 memset(&sn, 0, sizeof(sn));
1265 pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
1266
1267 qemu_gettimeofday(&tv);
1268 sn.date_sec = tv.tv_sec;
1269 sn.date_nsec = tv.tv_usec * 1000;
1270
1271 ret = bdrv_snapshot_create(bs, &sn);
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001272 if (ret) {
Jes Sorensen15654a62010-12-16 14:31:53 +01001273 error_report("Could not create snapshot '%s': %d (%s)",
aliguorif7b4a942009-01-07 17:40:15 +00001274 snapshot_name, ret, strerror(-ret));
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001275 }
aliguorif7b4a942009-01-07 17:40:15 +00001276 break;
1277
1278 case SNAPSHOT_APPLY:
1279 ret = bdrv_snapshot_goto(bs, snapshot_name);
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001280 if (ret) {
Jes Sorensen15654a62010-12-16 14:31:53 +01001281 error_report("Could not apply snapshot '%s': %d (%s)",
aliguorif7b4a942009-01-07 17:40:15 +00001282 snapshot_name, ret, strerror(-ret));
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001283 }
aliguorif7b4a942009-01-07 17:40:15 +00001284 break;
1285
1286 case SNAPSHOT_DELETE:
1287 ret = bdrv_snapshot_delete(bs, snapshot_name);
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001288 if (ret) {
Jes Sorensen15654a62010-12-16 14:31:53 +01001289 error_report("Could not delete snapshot '%s': %d (%s)",
aliguorif7b4a942009-01-07 17:40:15 +00001290 snapshot_name, ret, strerror(-ret));
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001291 }
aliguorif7b4a942009-01-07 17:40:15 +00001292 break;
1293 }
1294
1295 /* Cleanup */
1296 bdrv_delete(bs);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001297 if (ret) {
1298 return 1;
1299 }
Stuart Brady153859b2009-06-07 00:42:17 +01001300 return 0;
aliguorif7b4a942009-01-07 17:40:15 +00001301}
1302
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001303static int img_rebase(int argc, char **argv)
1304{
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001305 BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
Stefan Hajnoczif163d072010-04-13 10:29:34 +01001306 BlockDriver *old_backing_drv, *new_backing_drv;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001307 char *filename;
Federico Simoncelli661a0f72011-06-20 12:48:19 -04001308 const char *fmt, *cache, *out_basefmt, *out_baseimg;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001309 int c, flags, ret;
1310 int unsafe = 0;
Jes Sorensen6b837bc2011-03-30 14:16:25 +02001311 int progress = 0;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001312
1313 /* Parse commandline parameters */
Kevin Wolfe53dbee2010-03-02 12:14:31 +01001314 fmt = NULL;
Federico Simoncelli661a0f72011-06-20 12:48:19 -04001315 cache = BDRV_DEFAULT_CACHE;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001316 out_baseimg = NULL;
1317 out_basefmt = NULL;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001318 for(;;) {
Federico Simoncelli661a0f72011-06-20 12:48:19 -04001319 c = getopt(argc, argv, "uhf:F:b:pt:");
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001320 if (c == -1) {
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001321 break;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001322 }
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001323 switch(c) {
Jes Sorensenef873942010-12-06 15:25:40 +01001324 case '?':
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001325 case 'h':
1326 help();
1327 return 0;
Kevin Wolfe53dbee2010-03-02 12:14:31 +01001328 case 'f':
1329 fmt = optarg;
1330 break;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001331 case 'F':
1332 out_basefmt = optarg;
1333 break;
1334 case 'b':
1335 out_baseimg = optarg;
1336 break;
1337 case 'u':
1338 unsafe = 1;
1339 break;
Jes Sorensen6b837bc2011-03-30 14:16:25 +02001340 case 'p':
1341 progress = 1;
1342 break;
Federico Simoncelli661a0f72011-06-20 12:48:19 -04001343 case 't':
1344 cache = optarg;
1345 break;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001346 }
1347 }
1348
Anthony Liguori9a9d9db2011-04-13 15:51:47 +01001349 if ((optind >= argc) || (!unsafe && !out_baseimg)) {
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001350 help();
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001351 }
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001352 filename = argv[optind++];
1353
Jes Sorensen6b837bc2011-03-30 14:16:25 +02001354 qemu_progress_init(progress, 2.0);
1355 qemu_progress_print(0, 100);
1356
Federico Simoncelli661a0f72011-06-20 12:48:19 -04001357 flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +01001358 ret = bdrv_parse_cache_flags(cache, &flags);
Federico Simoncelli661a0f72011-06-20 12:48:19 -04001359 if (ret < 0) {
1360 error_report("Invalid cache option: %s", cache);
1361 return -1;
1362 }
1363
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001364 /*
1365 * Open the images.
1366 *
1367 * Ignore the old backing file for unsafe rebase in case we want to correct
1368 * the reference to a renamed or moved backing file.
1369 */
Stefan Hajnoczif163d072010-04-13 10:29:34 +01001370 bs = bdrv_new_open(filename, fmt, flags);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001371 if (!bs) {
1372 return 1;
1373 }
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001374
1375 /* Find the right drivers for the backing files */
1376 old_backing_drv = NULL;
1377 new_backing_drv = NULL;
1378
1379 if (!unsafe && bs->backing_format[0] != '\0') {
1380 old_backing_drv = bdrv_find_format(bs->backing_format);
1381 if (old_backing_drv == NULL) {
Jes Sorensen15654a62010-12-16 14:31:53 +01001382 error_report("Invalid format name: '%s'", bs->backing_format);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001383 ret = -1;
1384 goto out;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001385 }
1386 }
1387
1388 if (out_basefmt != NULL) {
1389 new_backing_drv = bdrv_find_format(out_basefmt);
1390 if (new_backing_drv == NULL) {
Jes Sorensen15654a62010-12-16 14:31:53 +01001391 error_report("Invalid format name: '%s'", out_basefmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001392 ret = -1;
1393 goto out;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001394 }
1395 }
1396
1397 /* For safe rebasing we need to compare old and new backing file */
1398 if (unsafe) {
1399 /* Make the compiler happy */
1400 bs_old_backing = NULL;
1401 bs_new_backing = NULL;
1402 } else {
1403 char backing_name[1024];
1404
1405 bs_old_backing = bdrv_new("old_backing");
1406 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001407 ret = bdrv_open(bs_old_backing, backing_name, BDRV_O_FLAGS,
1408 old_backing_drv);
1409 if (ret) {
Jes Sorensen15654a62010-12-16 14:31:53 +01001410 error_report("Could not open old backing file '%s'", backing_name);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001411 goto out;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001412 }
1413
1414 bs_new_backing = bdrv_new("new_backing");
Kevin Wolfcdbae852010-08-17 18:58:55 +02001415 ret = bdrv_open(bs_new_backing, out_baseimg, BDRV_O_FLAGS,
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001416 new_backing_drv);
1417 if (ret) {
Jes Sorensen15654a62010-12-16 14:31:53 +01001418 error_report("Could not open new backing file '%s'", out_baseimg);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001419 goto out;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001420 }
1421 }
1422
1423 /*
1424 * Check each unallocated cluster in the COW file. If it is unallocated,
1425 * accesses go to the backing file. We must therefore compare this cluster
1426 * in the old and new backing file, and if they differ we need to copy it
1427 * from the old backing file into the COW file.
1428 *
1429 * If qemu-img crashes during this step, no harm is done. The content of
1430 * the image is the same as the original one at any time.
1431 */
1432 if (!unsafe) {
1433 uint64_t num_sectors;
Kevin Wolf87a1b3e2011-12-07 12:42:10 +01001434 uint64_t old_backing_num_sectors;
1435 uint64_t new_backing_num_sectors;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001436 uint64_t sector;
Kevin Wolfcc60e322010-04-29 14:47:48 +02001437 int n;
TeLeMand6771bf2010-02-08 16:20:00 +08001438 uint8_t * buf_old;
1439 uint8_t * buf_new;
Jes Sorensen6b837bc2011-03-30 14:16:25 +02001440 float local_progress;
TeLeMand6771bf2010-02-08 16:20:00 +08001441
Kevin Wolfbb1c0592011-08-08 14:09:12 +02001442 buf_old = qemu_blockalign(bs, IO_BUF_SIZE);
1443 buf_new = qemu_blockalign(bs, IO_BUF_SIZE);
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001444
1445 bdrv_get_geometry(bs, &num_sectors);
Kevin Wolf87a1b3e2011-12-07 12:42:10 +01001446 bdrv_get_geometry(bs_old_backing, &old_backing_num_sectors);
1447 bdrv_get_geometry(bs_new_backing, &new_backing_num_sectors);
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001448
Jes Sorensen6b837bc2011-03-30 14:16:25 +02001449 local_progress = (float)100 /
Jes Sorensen4ee96412011-05-06 11:39:11 +02001450 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001451 for (sector = 0; sector < num_sectors; sector += n) {
1452
1453 /* How many sectors can we handle with the next read? */
1454 if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
1455 n = (IO_BUF_SIZE / 512);
1456 } else {
1457 n = num_sectors - sector;
1458 }
1459
1460 /* If the cluster is allocated, we don't need to take action */
Kevin Wolfcc60e322010-04-29 14:47:48 +02001461 ret = bdrv_is_allocated(bs, sector, n, &n);
1462 if (ret) {
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001463 continue;
1464 }
1465
Kevin Wolf87a1b3e2011-12-07 12:42:10 +01001466 /*
1467 * Read old and new backing file and take into consideration that
1468 * backing files may be smaller than the COW image.
1469 */
1470 if (sector >= old_backing_num_sectors) {
1471 memset(buf_old, 0, n * BDRV_SECTOR_SIZE);
1472 } else {
1473 if (sector + n > old_backing_num_sectors) {
1474 n = old_backing_num_sectors - sector;
1475 }
1476
1477 ret = bdrv_read(bs_old_backing, sector, buf_old, n);
1478 if (ret < 0) {
1479 error_report("error while reading from old backing file");
1480 goto out;
1481 }
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001482 }
Kevin Wolf87a1b3e2011-12-07 12:42:10 +01001483
1484 if (sector >= new_backing_num_sectors) {
1485 memset(buf_new, 0, n * BDRV_SECTOR_SIZE);
1486 } else {
1487 if (sector + n > new_backing_num_sectors) {
1488 n = new_backing_num_sectors - sector;
1489 }
1490
1491 ret = bdrv_read(bs_new_backing, sector, buf_new, n);
1492 if (ret < 0) {
1493 error_report("error while reading from new backing file");
1494 goto out;
1495 }
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001496 }
1497
1498 /* If they differ, we need to write to the COW file */
1499 uint64_t written = 0;
1500
1501 while (written < n) {
1502 int pnum;
1503
1504 if (compare_sectors(buf_old + written * 512,
Kevin Wolf60b1bd42010-02-17 12:32:59 +01001505 buf_new + written * 512, n - written, &pnum))
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001506 {
1507 ret = bdrv_write(bs, sector + written,
1508 buf_old + written * 512, pnum);
1509 if (ret < 0) {
Jes Sorensen15654a62010-12-16 14:31:53 +01001510 error_report("Error while writing to COW image: %s",
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001511 strerror(-ret));
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001512 goto out;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001513 }
1514 }
1515
1516 written += pnum;
1517 }
Jes Sorensen6b837bc2011-03-30 14:16:25 +02001518 qemu_progress_print(local_progress, 100);
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001519 }
TeLeMand6771bf2010-02-08 16:20:00 +08001520
Kevin Wolfbb1c0592011-08-08 14:09:12 +02001521 qemu_vfree(buf_old);
1522 qemu_vfree(buf_new);
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001523 }
1524
1525 /*
1526 * Change the backing file. All clusters that are different from the old
1527 * backing file are overwritten in the COW file now, so the visible content
1528 * doesn't change when we switch the backing file.
1529 */
1530 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
1531 if (ret == -ENOSPC) {
Jes Sorensen15654a62010-12-16 14:31:53 +01001532 error_report("Could not change the backing file to '%s': No "
1533 "space left in the file header", out_baseimg);
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001534 } else if (ret < 0) {
Jes Sorensen15654a62010-12-16 14:31:53 +01001535 error_report("Could not change the backing file to '%s': %s",
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001536 out_baseimg, strerror(-ret));
1537 }
1538
Jes Sorensen6b837bc2011-03-30 14:16:25 +02001539 qemu_progress_print(100, 0);
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001540 /*
1541 * TODO At this point it is possible to check if any clusters that are
1542 * allocated in the COW file are the same in the backing file. If so, they
1543 * could be dropped from the COW file. Don't do this before switching the
1544 * backing file, in case of a crash this would lead to corruption.
1545 */
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001546out:
Jes Sorensen6b837bc2011-03-30 14:16:25 +02001547 qemu_progress_end();
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001548 /* Cleanup */
1549 if (!unsafe) {
Kevin Wolfeb863ad2011-03-31 12:39:51 +02001550 if (bs_old_backing != NULL) {
1551 bdrv_delete(bs_old_backing);
1552 }
1553 if (bs_new_backing != NULL) {
1554 bdrv_delete(bs_new_backing);
1555 }
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001556 }
1557
1558 bdrv_delete(bs);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001559 if (ret) {
1560 return 1;
1561 }
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001562 return 0;
1563}
1564
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001565static int img_resize(int argc, char **argv)
1566{
1567 int c, ret, relative;
1568 const char *filename, *fmt, *size;
1569 int64_t n, total_size;
Jes Sorensen2a819982010-12-06 17:08:31 +01001570 BlockDriverState *bs = NULL;
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001571 QEMUOptionParameter *param;
1572 QEMUOptionParameter resize_options[] = {
1573 {
1574 .name = BLOCK_OPT_SIZE,
1575 .type = OPT_SIZE,
1576 .help = "Virtual disk size"
1577 },
1578 { NULL }
1579 };
1580
Kevin Wolfe80fec72011-04-29 10:58:12 +02001581 /* Remove size from argv manually so that negative numbers are not treated
1582 * as options by getopt. */
1583 if (argc < 3) {
1584 help();
1585 return 1;
1586 }
1587
1588 size = argv[--argc];
1589
1590 /* Parse getopt arguments */
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001591 fmt = NULL;
1592 for(;;) {
1593 c = getopt(argc, argv, "f:h");
1594 if (c == -1) {
1595 break;
1596 }
1597 switch(c) {
Jes Sorensenef873942010-12-06 15:25:40 +01001598 case '?':
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001599 case 'h':
1600 help();
1601 break;
1602 case 'f':
1603 fmt = optarg;
1604 break;
1605 }
1606 }
Kevin Wolfe80fec72011-04-29 10:58:12 +02001607 if (optind >= argc) {
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001608 help();
1609 }
1610 filename = argv[optind++];
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001611
1612 /* Choose grow, shrink, or absolute resize mode */
1613 switch (size[0]) {
1614 case '+':
1615 relative = 1;
1616 size++;
1617 break;
1618 case '-':
1619 relative = -1;
1620 size++;
1621 break;
1622 default:
1623 relative = 0;
1624 break;
1625 }
1626
1627 /* Parse size */
1628 param = parse_option_parameters("", resize_options, NULL);
1629 if (set_option_parameter(param, BLOCK_OPT_SIZE, size)) {
1630 /* Error message already printed when size parsing fails */
Jes Sorensen2a819982010-12-06 17:08:31 +01001631 ret = -1;
1632 goto out;
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001633 }
1634 n = get_option_parameter(param, BLOCK_OPT_SIZE)->value.n;
1635 free_option_parameters(param);
1636
1637 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001638 if (!bs) {
Jes Sorensen2a819982010-12-06 17:08:31 +01001639 ret = -1;
1640 goto out;
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001641 }
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001642
1643 if (relative) {
1644 total_size = bdrv_getlength(bs) + n * relative;
1645 } else {
1646 total_size = n;
1647 }
1648 if (total_size <= 0) {
Jes Sorensen15654a62010-12-16 14:31:53 +01001649 error_report("New image size must be positive");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001650 ret = -1;
1651 goto out;
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001652 }
1653
1654 ret = bdrv_truncate(bs, total_size);
1655 switch (ret) {
1656 case 0:
1657 printf("Image resized.\n");
1658 break;
1659 case -ENOTSUP:
Kevin Wolf259b2172012-03-06 12:44:45 +01001660 error_report("This image does not support resize");
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001661 break;
1662 case -EACCES:
Jes Sorensen15654a62010-12-16 14:31:53 +01001663 error_report("Image is read-only");
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001664 break;
1665 default:
Jes Sorensen15654a62010-12-16 14:31:53 +01001666 error_report("Error resizing image (%d)", -ret);
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001667 break;
1668 }
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001669out:
Jes Sorensen2a819982010-12-06 17:08:31 +01001670 if (bs) {
1671 bdrv_delete(bs);
1672 }
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001673 if (ret) {
1674 return 1;
1675 }
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001676 return 0;
1677}
1678
Anthony Liguoric227f092009-10-01 16:12:16 -05001679static const img_cmd_t img_cmds[] = {
Stuart Brady153859b2009-06-07 00:42:17 +01001680#define DEF(option, callback, arg_string) \
1681 { option, callback },
1682#include "qemu-img-cmds.h"
1683#undef DEF
1684#undef GEN_DOCS
1685 { NULL, NULL, },
1686};
1687
bellardea2384d2004-08-01 21:59:26 +00001688int main(int argc, char **argv)
1689{
Anthony Liguoric227f092009-10-01 16:12:16 -05001690 const img_cmd_t *cmd;
Stuart Brady153859b2009-06-07 00:42:17 +01001691 const char *cmdname;
bellardea2384d2004-08-01 21:59:26 +00001692
Kevin Wolf53f76e52010-12-16 15:10:32 +01001693 error_set_progname(argv[0]);
1694
bellardea2384d2004-08-01 21:59:26 +00001695 bdrv_init();
1696 if (argc < 2)
1697 help();
Stuart Brady153859b2009-06-07 00:42:17 +01001698 cmdname = argv[1];
aurel328f9b1572009-02-09 18:14:31 +00001699 argc--; argv++;
Stuart Brady153859b2009-06-07 00:42:17 +01001700
Zhi Yong Wu67d384e2012-02-19 22:24:35 +08001701 qemu_init_main_loop();
1702
Stuart Brady153859b2009-06-07 00:42:17 +01001703 /* find the command */
1704 for(cmd = img_cmds; cmd->name != NULL; cmd++) {
1705 if (!strcmp(cmdname, cmd->name)) {
1706 return cmd->handler(argc, argv);
1707 }
bellardea2384d2004-08-01 21:59:26 +00001708 }
Stuart Brady153859b2009-06-07 00:42:17 +01001709
1710 /* not found */
1711 help();
bellardea2384d2004-08-01 21:59:26 +00001712 return 0;
1713}