blob: e29e01b729e76002f9fe0daec5dfdc753cbd40b7 [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 */
Benoît Canetc054b3f2012-09-05 13:09:02 +020024#include "qapi-visit.h"
25#include "qapi/qmp-output-visitor.h"
26#include "qjson.h"
pbrookfaf07962007-11-11 02:51:17 +000027#include "qemu-common.h"
Kevin Wolf9ea2ea72009-05-18 16:42:11 +020028#include "qemu-option.h"
Kevin Wolf53f76e52010-12-16 15:10:32 +010029#include "qemu-error.h"
aliguorif7b4a942009-01-07 17:40:15 +000030#include "osdep.h"
Jes Sorensendc786bc2010-10-26 10:39:23 +020031#include "sysemu.h"
thsec36ba12007-09-16 21:59:02 +000032#include "block_int.h"
Benoît Canetc054b3f2012-09-05 13:09:02 +020033#include <getopt.h>
aliguori9230eaf2009-03-28 17:55:19 +000034#include <stdio.h>
bellardea2384d2004-08-01 21:59:26 +000035
bellarde8445332006-06-14 15:32:10 +000036#ifdef _WIN32
37#include <windows.h>
38#endif
39
Anthony Liguoric227f092009-10-01 16:12:16 -050040typedef struct img_cmd_t {
Stuart Brady153859b2009-06-07 00:42:17 +010041 const char *name;
42 int (*handler)(int argc, char **argv);
Anthony Liguoric227f092009-10-01 16:12:16 -050043} img_cmd_t;
Stuart Brady153859b2009-06-07 00:42:17 +010044
aurel32137519c2008-11-30 19:12:49 +000045/* Default to cache=writeback as data integrity is not important for qemu-tcg. */
Stefan Hajnocziadfe0782010-04-13 10:29:35 +010046#define BDRV_O_FLAGS BDRV_O_CACHE_WB
Federico Simoncelli661a0f72011-06-20 12:48:19 -040047#define BDRV_DEFAULT_CACHE "writeback"
aurel32137519c2008-11-30 19:12:49 +000048
bellardea2384d2004-08-01 21:59:26 +000049static void format_print(void *opaque, const char *name)
50{
51 printf(" %s", name);
52}
53
blueswir1d2c639d2009-01-24 18:19:25 +000054/* Please keep in synch with qemu-img.texi */
pbrook3f379ab2007-11-11 03:33:13 +000055static void help(void)
bellardea2384d2004-08-01 21:59:26 +000056{
Paolo Bonzinie00291c2010-02-04 16:49:56 +010057 const char *help_msg =
58 "qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n"
malc3f020d72010-02-08 12:04:56 +030059 "usage: qemu-img command [command options]\n"
60 "QEMU disk image utility\n"
61 "\n"
62 "Command syntax:\n"
Stuart Brady153859b2009-06-07 00:42:17 +010063#define DEF(option, callback, arg_string) \
64 " " arg_string "\n"
65#include "qemu-img-cmds.h"
66#undef DEF
67#undef GEN_DOCS
malc3f020d72010-02-08 12:04:56 +030068 "\n"
69 "Command parameters:\n"
70 " 'filename' is a disk image filename\n"
71 " 'fmt' is the disk image format. It is guessed automatically in most cases\n"
Federico Simoncelli661a0f72011-06-20 12:48:19 -040072 " 'cache' is the cache mode used to write the output disk image, the valid\n"
Liu Yuan80ccf932012-04-20 17:10:56 +080073 " options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n"
74 " 'directsync' and 'unsafe' (default for convert)\n"
malc3f020d72010-02-08 12:04:56 +030075 " 'size' is the disk image size in bytes. Optional suffixes\n"
76 " 'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n"
77 " and T (terabyte, 1024G) are supported. 'b' is ignored.\n"
78 " 'output_filename' is the destination disk image filename\n"
79 " 'output_fmt' is the destination format\n"
80 " 'options' is a comma separated list of format specific options in a\n"
81 " name=value format. Use -o ? for an overview of the options supported by the\n"
82 " used format\n"
83 " '-c' indicates that target image must be compressed (qcow format only)\n"
84 " '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
85 " match exactly. The image doesn't need a working backing file before\n"
86 " rebasing in this case (useful for renaming the backing file)\n"
87 " '-h' with or without a command shows this help and lists the supported formats\n"
Jes Sorensen6b837bc2011-03-30 14:16:25 +020088 " '-p' show progress of command (only certain commands)\n"
Kevin Wolfa22f1232011-08-26 15:27:13 +020089 " '-S' indicates the consecutive number of bytes that must contain only zeros\n"
90 " for qemu-img to create a sparse image during conversion\n"
Benoît Canetc054b3f2012-09-05 13:09:02 +020091 " '--output' takes the format in which the output must be done (human or json)\n"
malc3f020d72010-02-08 12:04:56 +030092 "\n"
Kevin Wolf4534ff52012-05-11 16:07:02 +020093 "Parameters to check subcommand:\n"
94 " '-r' tries to repair any inconsistencies that are found during the check.\n"
95 " '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n"
96 " kinds of errors, with a higher risk of choosing the wrong fix or\n"
Stefan Weil0546b8c2012-08-10 22:03:25 +020097 " hiding corruption that has already occurred.\n"
Kevin Wolf4534ff52012-05-11 16:07:02 +020098 "\n"
malc3f020d72010-02-08 12:04:56 +030099 "Parameters to snapshot subcommand:\n"
100 " 'snapshot' is the name of the snapshot to create, apply or delete\n"
101 " '-a' applies a snapshot (revert disk to saved state)\n"
102 " '-c' creates a snapshot\n"
103 " '-d' deletes a snapshot\n"
Paolo Bonzinie00291c2010-02-04 16:49:56 +0100104 " '-l' lists all snapshots in the given image\n";
105
106 printf("%s\nSupported formats:", help_msg);
bellardea2384d2004-08-01 21:59:26 +0000107 bdrv_iterate_format(format_print, NULL);
108 printf("\n");
109 exit(1);
110}
111
bellardea2384d2004-08-01 21:59:26 +0000112#if defined(WIN32)
113/* XXX: put correct support for win32 */
114static int read_password(char *buf, int buf_size)
115{
116 int c, i;
117 printf("Password: ");
118 fflush(stdout);
119 i = 0;
120 for(;;) {
121 c = getchar();
122 if (c == '\n')
123 break;
124 if (i < (buf_size - 1))
125 buf[i++] = c;
126 }
127 buf[i] = '\0';
128 return 0;
129}
130
131#else
132
133#include <termios.h>
134
135static struct termios oldtty;
136
137static void term_exit(void)
138{
139 tcsetattr (0, TCSANOW, &oldtty);
140}
141
142static void term_init(void)
143{
144 struct termios tty;
145
146 tcgetattr (0, &tty);
147 oldtty = tty;
148
149 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
150 |INLCR|IGNCR|ICRNL|IXON);
151 tty.c_oflag |= OPOST;
152 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
153 tty.c_cflag &= ~(CSIZE|PARENB);
154 tty.c_cflag |= CS8;
155 tty.c_cc[VMIN] = 1;
156 tty.c_cc[VTIME] = 0;
ths3b46e622007-09-17 08:09:54 +0000157
bellardea2384d2004-08-01 21:59:26 +0000158 tcsetattr (0, TCSANOW, &tty);
159
160 atexit(term_exit);
161}
162
pbrook3f379ab2007-11-11 03:33:13 +0000163static int read_password(char *buf, int buf_size)
bellardea2384d2004-08-01 21:59:26 +0000164{
165 uint8_t ch;
166 int i, ret;
167
168 printf("password: ");
169 fflush(stdout);
170 term_init();
171 i = 0;
172 for(;;) {
173 ret = read(0, &ch, 1);
174 if (ret == -1) {
175 if (errno == EAGAIN || errno == EINTR) {
176 continue;
177 } else {
178 ret = -1;
179 break;
180 }
181 } else if (ret == 0) {
182 ret = -1;
183 break;
184 } else {
185 if (ch == '\r') {
186 ret = 0;
187 break;
188 }
189 if (i < (buf_size - 1))
190 buf[i++] = ch;
191 }
192 }
193 term_exit();
194 buf[i] = '\0';
195 printf("\n");
196 return ret;
197}
198#endif
199
Jes Sorensen4ac8aac2010-12-06 15:25:38 +0100200static int print_block_option_help(const char *filename, const char *fmt)
201{
202 BlockDriver *drv, *proto_drv;
203 QEMUOptionParameter *create_options = NULL;
204
205 /* Find driver and parse its options */
206 drv = bdrv_find_format(fmt);
207 if (!drv) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100208 error_report("Unknown file format '%s'", fmt);
Jes Sorensen4ac8aac2010-12-06 15:25:38 +0100209 return 1;
210 }
211
212 proto_drv = bdrv_find_protocol(filename);
213 if (!proto_drv) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100214 error_report("Unknown protocol '%s'", filename);
Jes Sorensen4ac8aac2010-12-06 15:25:38 +0100215 return 1;
216 }
217
218 create_options = append_option_parameters(create_options,
219 drv->create_options);
220 create_options = append_option_parameters(create_options,
221 proto_drv->create_options);
222 print_option_help(create_options);
223 free_option_parameters(create_options);
224 return 0;
225}
226
bellard75c23802004-08-27 21:28:58 +0000227static BlockDriverState *bdrv_new_open(const char *filename,
Sheng Yang9bc378c2010-01-29 10:15:06 +0800228 const char *fmt,
Daniel P. Berrangef0536bb2012-09-10 12:11:31 +0100229 int flags,
230 bool require_io)
bellard75c23802004-08-27 21:28:58 +0000231{
232 BlockDriverState *bs;
233 BlockDriver *drv;
234 char password[256];
Kevin Wolfb9eaf9e2011-02-09 11:25:53 +0100235 int ret;
bellard75c23802004-08-27 21:28:58 +0000236
Kevin Wolfb9eaf9e2011-02-09 11:25:53 +0100237 bs = bdrv_new("image");
Kevin Wolfad717132010-12-16 15:37:41 +0100238
bellard75c23802004-08-27 21:28:58 +0000239 if (fmt) {
240 drv = bdrv_find_format(fmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900241 if (!drv) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100242 error_report("Unknown file format '%s'", fmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900243 goto fail;
244 }
bellard75c23802004-08-27 21:28:58 +0000245 } else {
246 drv = NULL;
247 }
Kevin Wolfb9eaf9e2011-02-09 11:25:53 +0100248
249 ret = bdrv_open(bs, filename, flags, drv);
250 if (ret < 0) {
251 error_report("Could not open '%s': %s", filename, strerror(-ret));
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900252 goto fail;
bellard75c23802004-08-27 21:28:58 +0000253 }
Kevin Wolfb9eaf9e2011-02-09 11:25:53 +0100254
Daniel P. Berrangef0536bb2012-09-10 12:11:31 +0100255 if (bdrv_is_encrypted(bs) && require_io) {
bellard75c23802004-08-27 21:28:58 +0000256 printf("Disk image '%s' is encrypted.\n", filename);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900257 if (read_password(password, sizeof(password)) < 0) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100258 error_report("No password given");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900259 goto fail;
260 }
261 if (bdrv_set_key(bs, password) < 0) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100262 error_report("invalid password");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900263 goto fail;
264 }
bellard75c23802004-08-27 21:28:58 +0000265 }
266 return bs;
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900267fail:
268 if (bs) {
269 bdrv_delete(bs);
270 }
271 return NULL;
bellard75c23802004-08-27 21:28:58 +0000272}
273
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900274static int add_old_style_options(const char *fmt, QEMUOptionParameter *list,
Jes Sorenseneec77d92010-12-07 17:44:34 +0100275 const char *base_filename,
276 const char *base_fmt)
Kevin Wolfefa84d42009-05-18 16:42:12 +0200277{
Kevin Wolfefa84d42009-05-18 16:42:12 +0200278 if (base_filename) {
279 if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100280 error_report("Backing file not supported for file format '%s'",
281 fmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900282 return -1;
Kevin Wolfefa84d42009-05-18 16:42:12 +0200283 }
284 }
285 if (base_fmt) {
286 if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100287 error_report("Backing file format not supported for file "
288 "format '%s'", fmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900289 return -1;
Kevin Wolfefa84d42009-05-18 16:42:12 +0200290 }
291 }
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900292 return 0;
Kevin Wolfefa84d42009-05-18 16:42:12 +0200293}
294
bellardea2384d2004-08-01 21:59:26 +0000295static int img_create(int argc, char **argv)
296{
Jes Sorenseneec77d92010-12-07 17:44:34 +0100297 int c, ret = 0;
Jes Sorensen1da7cfb2010-12-09 14:17:25 +0100298 uint64_t img_size = -1;
bellardea2384d2004-08-01 21:59:26 +0000299 const char *fmt = "raw";
aliguori9230eaf2009-03-28 17:55:19 +0000300 const char *base_fmt = NULL;
bellardea2384d2004-08-01 21:59:26 +0000301 const char *filename;
302 const char *base_filename = NULL;
Kevin Wolf9ea2ea72009-05-18 16:42:11 +0200303 char *options = NULL;
ths3b46e622007-09-17 08:09:54 +0000304
bellardea2384d2004-08-01 21:59:26 +0000305 for(;;) {
Kevin Wolf9ea2ea72009-05-18 16:42:11 +0200306 c = getopt(argc, argv, "F:b:f:he6o:");
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100307 if (c == -1) {
bellardea2384d2004-08-01 21:59:26 +0000308 break;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100309 }
bellardea2384d2004-08-01 21:59:26 +0000310 switch(c) {
Jes Sorensenef873942010-12-06 15:25:40 +0100311 case '?':
bellardea2384d2004-08-01 21:59:26 +0000312 case 'h':
313 help();
314 break;
aliguori9230eaf2009-03-28 17:55:19 +0000315 case 'F':
316 base_fmt = optarg;
317 break;
bellardea2384d2004-08-01 21:59:26 +0000318 case 'b':
319 base_filename = optarg;
320 break;
321 case 'f':
322 fmt = optarg;
323 break;
324 case 'e':
Markus Armbruster9d42e152011-06-22 14:03:55 +0200325 error_report("option -e is deprecated, please use \'-o "
Jes Sorenseneec77d92010-12-07 17:44:34 +0100326 "encryption\' instead!");
327 return 1;
thsd8871c52007-10-24 16:11:42 +0000328 case '6':
Markus Armbruster9d42e152011-06-22 14:03:55 +0200329 error_report("option -6 is deprecated, please use \'-o "
Jes Sorenseneec77d92010-12-07 17:44:34 +0100330 "compat6\' instead!");
331 return 1;
Kevin Wolf9ea2ea72009-05-18 16:42:11 +0200332 case 'o':
333 options = optarg;
334 break;
bellardea2384d2004-08-01 21:59:26 +0000335 }
336 }
aliguori9230eaf2009-03-28 17:55:19 +0000337
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900338 /* Get the filename */
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100339 if (optind >= argc) {
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900340 help();
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100341 }
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900342 filename = argv[optind++];
343
Jes Sorensen1da7cfb2010-12-09 14:17:25 +0100344 /* Get image size, if specified */
345 if (optind < argc) {
Jes Sorensen70b4f4b2011-01-05 11:41:02 +0100346 int64_t sval;
Markus Armbrustere36b3692011-11-22 09:46:05 +0100347 char *end;
348 sval = strtosz_suffix(argv[optind++], &end, STRTOSZ_DEFSUFFIX_B);
349 if (sval < 0 || *end) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100350 error_report("Invalid image size specified! You may use k, M, G or "
Jes Sorensen1da7cfb2010-12-09 14:17:25 +0100351 "T suffixes for ");
Jes Sorensen15654a62010-12-16 14:31:53 +0100352 error_report("kilobytes, megabytes, gigabytes and terabytes.");
Jes Sorensen1da7cfb2010-12-09 14:17:25 +0100353 ret = -1;
354 goto out;
355 }
356 img_size = (uint64_t)sval;
357 }
358
Peter Maydellc8057f92012-08-02 13:45:54 +0100359 if (options && is_help_option(options)) {
Jes Sorensen4ac8aac2010-12-06 15:25:38 +0100360 ret = print_block_option_help(filename, fmt);
361 goto out;
362 }
363
Jes Sorensenf88e1a42010-12-16 13:52:15 +0100364 ret = bdrv_img_create(filename, fmt, base_filename, base_fmt,
365 options, img_size, BDRV_O_FLAGS);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900366out:
367 if (ret) {
368 return 1;
369 }
bellardea2384d2004-08-01 21:59:26 +0000370 return 0;
371}
372
Kevin Wolfe076f332010-06-29 11:43:13 +0200373/*
374 * Checks an image for consistency. Exit codes:
375 *
376 * 0 - Check completed, image is good
377 * 1 - Check not completed because of internal errors
378 * 2 - Check completed, image is corrupted
379 * 3 - Check completed, image has leaked clusters, but is good otherwise
380 */
aliguori15859692009-04-21 23:11:53 +0000381static int img_check(int argc, char **argv)
382{
383 int c, ret;
384 const char *filename, *fmt;
aliguori15859692009-04-21 23:11:53 +0000385 BlockDriverState *bs;
Kevin Wolfe076f332010-06-29 11:43:13 +0200386 BdrvCheckResult result;
Kevin Wolf4534ff52012-05-11 16:07:02 +0200387 int fix = 0;
Stefan Hajnoczi058f8f12012-08-09 13:05:56 +0100388 int flags = BDRV_O_FLAGS | BDRV_O_CHECK;
aliguori15859692009-04-21 23:11:53 +0000389
390 fmt = NULL;
391 for(;;) {
Kevin Wolf4534ff52012-05-11 16:07:02 +0200392 c = getopt(argc, argv, "f:hr:");
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100393 if (c == -1) {
aliguori15859692009-04-21 23:11:53 +0000394 break;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100395 }
aliguori15859692009-04-21 23:11:53 +0000396 switch(c) {
Jes Sorensenef873942010-12-06 15:25:40 +0100397 case '?':
aliguori15859692009-04-21 23:11:53 +0000398 case 'h':
399 help();
400 break;
401 case 'f':
402 fmt = optarg;
403 break;
Kevin Wolf4534ff52012-05-11 16:07:02 +0200404 case 'r':
405 flags |= BDRV_O_RDWR;
406
407 if (!strcmp(optarg, "leaks")) {
408 fix = BDRV_FIX_LEAKS;
409 } else if (!strcmp(optarg, "all")) {
410 fix = BDRV_FIX_LEAKS | BDRV_FIX_ERRORS;
411 } else {
412 help();
413 }
414 break;
aliguori15859692009-04-21 23:11:53 +0000415 }
416 }
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100417 if (optind >= argc) {
aliguori15859692009-04-21 23:11:53 +0000418 help();
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100419 }
aliguori15859692009-04-21 23:11:53 +0000420 filename = argv[optind++];
421
Daniel P. Berrangef0536bb2012-09-10 12:11:31 +0100422 bs = bdrv_new_open(filename, fmt, flags, true);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900423 if (!bs) {
424 return 1;
425 }
Kevin Wolf4534ff52012-05-11 16:07:02 +0200426 ret = bdrv_check(bs, &result, fix);
Kevin Wolfe076f332010-06-29 11:43:13 +0200427
428 if (ret == -ENOTSUP) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100429 error_report("This image format does not support checks");
Kevin Wolfe076f332010-06-29 11:43:13 +0200430 bdrv_delete(bs);
431 return 1;
432 }
433
Kevin Wolfccf34712012-05-11 18:16:54 +0200434 if (result.corruptions_fixed || result.leaks_fixed) {
435 printf("The following inconsistencies were found and repaired:\n\n"
436 " %d leaked clusters\n"
437 " %d corruptions\n\n"
438 "Double checking the fixed image now...\n",
439 result.leaks_fixed,
440 result.corruptions_fixed);
441 ret = bdrv_check(bs, &result, 0);
442 }
443
Kevin Wolfe076f332010-06-29 11:43:13 +0200444 if (!(result.corruptions || result.leaks || result.check_errors)) {
445 printf("No errors were found on the image.\n");
446 } else {
447 if (result.corruptions) {
448 printf("\n%d errors were found on the image.\n"
449 "Data may be corrupted, or further writes to the image "
450 "may corrupt it.\n",
451 result.corruptions);
aliguori15859692009-04-21 23:11:53 +0000452 }
Kevin Wolfe076f332010-06-29 11:43:13 +0200453
454 if (result.leaks) {
455 printf("\n%d leaked clusters were found on the image.\n"
456 "This means waste of disk space, but no harm to data.\n",
457 result.leaks);
458 }
459
460 if (result.check_errors) {
461 printf("\n%d internal errors have occurred during the check.\n",
462 result.check_errors);
463 }
aliguori15859692009-04-21 23:11:53 +0000464 }
465
Dong Xu Wangf8111c22012-03-15 20:13:31 +0800466 if (result.bfi.total_clusters != 0 && result.bfi.allocated_clusters != 0) {
467 printf("%" PRId64 "/%" PRId64 "= %0.2f%% allocated, %0.2f%% fragmented\n",
468 result.bfi.allocated_clusters, result.bfi.total_clusters,
469 result.bfi.allocated_clusters * 100.0 / result.bfi.total_clusters,
470 result.bfi.fragmented_clusters * 100.0 / result.bfi.allocated_clusters);
471 }
472
aliguori15859692009-04-21 23:11:53 +0000473 bdrv_delete(bs);
Kevin Wolfe076f332010-06-29 11:43:13 +0200474
475 if (ret < 0 || result.check_errors) {
476 printf("\nAn error has occurred during the check: %s\n"
477 "The check is not complete and may have missed error.\n",
478 strerror(-ret));
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900479 return 1;
480 }
Kevin Wolfe076f332010-06-29 11:43:13 +0200481
482 if (result.corruptions) {
483 return 2;
484 } else if (result.leaks) {
485 return 3;
486 } else {
487 return 0;
488 }
aliguori15859692009-04-21 23:11:53 +0000489}
490
bellardea2384d2004-08-01 21:59:26 +0000491static int img_commit(int argc, char **argv)
492{
Federico Simoncelli661a0f72011-06-20 12:48:19 -0400493 int c, ret, flags;
494 const char *filename, *fmt, *cache;
bellardea2384d2004-08-01 21:59:26 +0000495 BlockDriverState *bs;
496
497 fmt = NULL;
Federico Simoncelli661a0f72011-06-20 12:48:19 -0400498 cache = BDRV_DEFAULT_CACHE;
bellardea2384d2004-08-01 21:59:26 +0000499 for(;;) {
Federico Simoncelli661a0f72011-06-20 12:48:19 -0400500 c = getopt(argc, argv, "f:ht:");
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100501 if (c == -1) {
bellardea2384d2004-08-01 21:59:26 +0000502 break;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100503 }
bellardea2384d2004-08-01 21:59:26 +0000504 switch(c) {
Jes Sorensenef873942010-12-06 15:25:40 +0100505 case '?':
bellardea2384d2004-08-01 21:59:26 +0000506 case 'h':
507 help();
508 break;
509 case 'f':
510 fmt = optarg;
511 break;
Federico Simoncelli661a0f72011-06-20 12:48:19 -0400512 case 't':
513 cache = optarg;
514 break;
bellardea2384d2004-08-01 21:59:26 +0000515 }
516 }
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100517 if (optind >= argc) {
bellardea2384d2004-08-01 21:59:26 +0000518 help();
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100519 }
bellardea2384d2004-08-01 21:59:26 +0000520 filename = argv[optind++];
521
Federico Simoncelli661a0f72011-06-20 12:48:19 -0400522 flags = BDRV_O_RDWR;
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100523 ret = bdrv_parse_cache_flags(cache, &flags);
Federico Simoncelli661a0f72011-06-20 12:48:19 -0400524 if (ret < 0) {
525 error_report("Invalid cache option: %s", cache);
526 return -1;
527 }
528
Daniel P. Berrangef0536bb2012-09-10 12:11:31 +0100529 bs = bdrv_new_open(filename, fmt, flags, true);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900530 if (!bs) {
531 return 1;
532 }
bellardea2384d2004-08-01 21:59:26 +0000533 ret = bdrv_commit(bs);
534 switch(ret) {
535 case 0:
536 printf("Image committed.\n");
537 break;
538 case -ENOENT:
Jes Sorensen15654a62010-12-16 14:31:53 +0100539 error_report("No disk inserted");
bellardea2384d2004-08-01 21:59:26 +0000540 break;
541 case -EACCES:
Jes Sorensen15654a62010-12-16 14:31:53 +0100542 error_report("Image is read-only");
bellardea2384d2004-08-01 21:59:26 +0000543 break;
544 case -ENOTSUP:
Jes Sorensen15654a62010-12-16 14:31:53 +0100545 error_report("Image is already committed");
bellardea2384d2004-08-01 21:59:26 +0000546 break;
547 default:
Jes Sorensen15654a62010-12-16 14:31:53 +0100548 error_report("Error while committing image");
bellardea2384d2004-08-01 21:59:26 +0000549 break;
550 }
551
552 bdrv_delete(bs);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900553 if (ret) {
554 return 1;
555 }
bellardea2384d2004-08-01 21:59:26 +0000556 return 0;
557}
558
Dmitry Konishchevf6a00aa2011-05-18 15:03:59 +0400559/*
thsf58c7b32008-06-05 21:53:49 +0000560 * Returns true iff the first sector pointed to by 'buf' contains at least
561 * a non-NUL byte.
562 *
563 * 'pnum' is set to the number of sectors (including and immediately following
564 * the first one) that are known to be in the same allocated/unallocated state.
565 */
bellardea2384d2004-08-01 21:59:26 +0000566static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
567{
Stefan Hajnoczi1a6d39f2012-02-07 13:27:24 +0000568 bool is_zero;
569 int i;
bellardea2384d2004-08-01 21:59:26 +0000570
571 if (n <= 0) {
572 *pnum = 0;
573 return 0;
574 }
Stefan Hajnoczi1a6d39f2012-02-07 13:27:24 +0000575 is_zero = buffer_is_zero(buf, 512);
bellardea2384d2004-08-01 21:59:26 +0000576 for(i = 1; i < n; i++) {
577 buf += 512;
Stefan Hajnoczi1a6d39f2012-02-07 13:27:24 +0000578 if (is_zero != buffer_is_zero(buf, 512)) {
bellardea2384d2004-08-01 21:59:26 +0000579 break;
Stefan Hajnoczi1a6d39f2012-02-07 13:27:24 +0000580 }
bellardea2384d2004-08-01 21:59:26 +0000581 }
582 *pnum = i;
Stefan Hajnoczi1a6d39f2012-02-07 13:27:24 +0000583 return !is_zero;
bellardea2384d2004-08-01 21:59:26 +0000584}
585
Kevin Wolf3e85c6f2010-01-12 12:55:18 +0100586/*
Kevin Wolfa22f1232011-08-26 15:27:13 +0200587 * Like is_allocated_sectors, but if the buffer starts with a used sector,
588 * up to 'min' consecutive sectors containing zeros are ignored. This avoids
589 * breaking up write requests for only small sparse areas.
590 */
591static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
592 int min)
593{
594 int ret;
595 int num_checked, num_used;
596
597 if (n < min) {
598 min = n;
599 }
600
601 ret = is_allocated_sectors(buf, n, pnum);
602 if (!ret) {
603 return ret;
604 }
605
606 num_used = *pnum;
607 buf += BDRV_SECTOR_SIZE * *pnum;
608 n -= *pnum;
609 num_checked = num_used;
610
611 while (n > 0) {
612 ret = is_allocated_sectors(buf, n, pnum);
613
614 buf += BDRV_SECTOR_SIZE * *pnum;
615 n -= *pnum;
616 num_checked += *pnum;
617 if (ret) {
618 num_used = num_checked;
619 } else if (*pnum >= min) {
620 break;
621 }
622 }
623
624 *pnum = num_used;
625 return 1;
626}
627
628/*
Kevin Wolf3e85c6f2010-01-12 12:55:18 +0100629 * Compares two buffers sector by sector. Returns 0 if the first sector of both
630 * buffers matches, non-zero otherwise.
631 *
632 * pnum is set to the number of sectors (including and immediately following
633 * the first one) that are known to have the same comparison result
634 */
635static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
636 int *pnum)
637{
638 int res, i;
639
640 if (n <= 0) {
641 *pnum = 0;
642 return 0;
643 }
644
645 res = !!memcmp(buf1, buf2, 512);
646 for(i = 1; i < n; i++) {
647 buf1 += 512;
648 buf2 += 512;
649
650 if (!!memcmp(buf1, buf2, 512) != res) {
651 break;
652 }
653 }
654
655 *pnum = i;
656 return res;
657}
658
Kevin Wolf80ee15a2009-09-15 12:30:43 +0200659#define IO_BUF_SIZE (2 * 1024 * 1024)
bellardea2384d2004-08-01 21:59:26 +0000660
661static int img_convert(int argc, char **argv)
662{
Jes Sorenseneec77d92010-12-07 17:44:34 +0100663 int c, ret = 0, n, n1, bs_n, bs_i, compress, cluster_size, cluster_sectors;
Federico Simoncelli661a0f72011-06-20 12:48:19 -0400664 int progress = 0, flags;
665 const char *fmt, *out_fmt, *cache, *out_baseimg, *out_filename;
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900666 BlockDriver *drv, *proto_drv;
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900667 BlockDriverState **bs = NULL, *out_bs = NULL;
ths96b8f132007-12-17 01:35:20 +0000668 int64_t total_sectors, nb_sectors, sector_num, bs_offset;
669 uint64_t bs_sectors;
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900670 uint8_t * buf = NULL;
bellardea2384d2004-08-01 21:59:26 +0000671 const uint8_t *buf1;
bellardfaea38e2006-08-05 21:31:00 +0000672 BlockDriverInfo bdi;
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900673 QEMUOptionParameter *param = NULL, *create_options = NULL;
Kevin Wolfa18953f2010-10-14 15:46:04 +0200674 QEMUOptionParameter *out_baseimg_param;
Kevin Wolfefa84d42009-05-18 16:42:12 +0200675 char *options = NULL;
edison51ef6722010-09-21 19:58:41 -0700676 const char *snapshot_name = NULL;
Kevin Wolf1f710492012-10-12 14:29:18 +0200677 float local_progress = 0;
Kevin Wolfa22f1232011-08-26 15:27:13 +0200678 int min_sparse = 8; /* Need at least 4k of zeros for sparse detection */
bellardea2384d2004-08-01 21:59:26 +0000679
680 fmt = NULL;
681 out_fmt = "raw";
Federico Simoncelli661a0f72011-06-20 12:48:19 -0400682 cache = "unsafe";
thsf58c7b32008-06-05 21:53:49 +0000683 out_baseimg = NULL;
Jes Sorenseneec77d92010-12-07 17:44:34 +0100684 compress = 0;
bellardea2384d2004-08-01 21:59:26 +0000685 for(;;) {
Kevin Wolfa22f1232011-08-26 15:27:13 +0200686 c = getopt(argc, argv, "f:O:B:s:hce6o:pS:t:");
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100687 if (c == -1) {
bellardea2384d2004-08-01 21:59:26 +0000688 break;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100689 }
bellardea2384d2004-08-01 21:59:26 +0000690 switch(c) {
Jes Sorensenef873942010-12-06 15:25:40 +0100691 case '?':
bellardea2384d2004-08-01 21:59:26 +0000692 case 'h':
693 help();
694 break;
695 case 'f':
696 fmt = optarg;
697 break;
698 case 'O':
699 out_fmt = optarg;
700 break;
thsf58c7b32008-06-05 21:53:49 +0000701 case 'B':
702 out_baseimg = optarg;
703 break;
bellardea2384d2004-08-01 21:59:26 +0000704 case 'c':
Jes Sorenseneec77d92010-12-07 17:44:34 +0100705 compress = 1;
bellardea2384d2004-08-01 21:59:26 +0000706 break;
707 case 'e':
Markus Armbruster9d42e152011-06-22 14:03:55 +0200708 error_report("option -e is deprecated, please use \'-o "
Jes Sorenseneec77d92010-12-07 17:44:34 +0100709 "encryption\' instead!");
710 return 1;
thsec36ba12007-09-16 21:59:02 +0000711 case '6':
Markus Armbruster9d42e152011-06-22 14:03:55 +0200712 error_report("option -6 is deprecated, please use \'-o "
Jes Sorenseneec77d92010-12-07 17:44:34 +0100713 "compat6\' instead!");
714 return 1;
Kevin Wolfefa84d42009-05-18 16:42:12 +0200715 case 'o':
716 options = optarg;
717 break;
edison51ef6722010-09-21 19:58:41 -0700718 case 's':
719 snapshot_name = optarg;
720 break;
Kevin Wolfa22f1232011-08-26 15:27:13 +0200721 case 'S':
722 {
723 int64_t sval;
Markus Armbrustere36b3692011-11-22 09:46:05 +0100724 char *end;
725 sval = strtosz_suffix(optarg, &end, STRTOSZ_DEFSUFFIX_B);
726 if (sval < 0 || *end) {
Kevin Wolfa22f1232011-08-26 15:27:13 +0200727 error_report("Invalid minimum zero buffer size for sparse output specified");
728 return 1;
729 }
730
731 min_sparse = sval / BDRV_SECTOR_SIZE;
732 break;
733 }
Jes Sorensen6b837bc2011-03-30 14:16:25 +0200734 case 'p':
735 progress = 1;
736 break;
Federico Simoncelli661a0f72011-06-20 12:48:19 -0400737 case 't':
738 cache = optarg;
739 break;
bellardea2384d2004-08-01 21:59:26 +0000740 }
741 }
ths3b46e622007-09-17 08:09:54 +0000742
balrog926c2d22007-10-31 01:11:44 +0000743 bs_n = argc - optind - 1;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100744 if (bs_n < 1) {
745 help();
746 }
balrog926c2d22007-10-31 01:11:44 +0000747
748 out_filename = argv[argc - 1];
thsf58c7b32008-06-05 21:53:49 +0000749
Charles Arnoldfa170c12012-05-11 10:57:54 -0600750 /* Initialize before goto out */
751 qemu_progress_init(progress, 2.0);
752
Peter Maydellc8057f92012-08-02 13:45:54 +0100753 if (options && is_help_option(options)) {
Jes Sorensen4ac8aac2010-12-06 15:25:38 +0100754 ret = print_block_option_help(out_filename, out_fmt);
755 goto out;
756 }
757
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900758 if (bs_n > 1 && out_baseimg) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100759 error_report("-B makes no sense when concatenating multiple input "
760 "images");
Jes Sorensen31ca34b2010-12-06 15:25:36 +0100761 ret = -1;
762 goto out;
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900763 }
Dong Xu Wangf8111c22012-03-15 20:13:31 +0800764
Jes Sorensen6b837bc2011-03-30 14:16:25 +0200765 qemu_progress_print(0, 100);
766
Anthony Liguori7267c092011-08-20 22:09:37 -0500767 bs = g_malloc0(bs_n * sizeof(BlockDriverState *));
balrog926c2d22007-10-31 01:11:44 +0000768
769 total_sectors = 0;
770 for (bs_i = 0; bs_i < bs_n; bs_i++) {
Daniel P. Berrangef0536bb2012-09-10 12:11:31 +0100771 bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, BDRV_O_FLAGS, true);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900772 if (!bs[bs_i]) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100773 error_report("Could not open '%s'", argv[optind + bs_i]);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900774 ret = -1;
775 goto out;
776 }
balrog926c2d22007-10-31 01:11:44 +0000777 bdrv_get_geometry(bs[bs_i], &bs_sectors);
778 total_sectors += bs_sectors;
779 }
bellardea2384d2004-08-01 21:59:26 +0000780
edison51ef6722010-09-21 19:58:41 -0700781 if (snapshot_name != NULL) {
782 if (bs_n > 1) {
Markus Armbruster6daf1942011-06-22 14:03:54 +0200783 error_report("No support for concatenating multiple snapshot");
edison51ef6722010-09-21 19:58:41 -0700784 ret = -1;
785 goto out;
786 }
787 if (bdrv_snapshot_load_tmp(bs[0], snapshot_name) < 0) {
Markus Armbruster6daf1942011-06-22 14:03:54 +0200788 error_report("Failed to load snapshot");
edison51ef6722010-09-21 19:58:41 -0700789 ret = -1;
790 goto out;
791 }
792 }
793
Kevin Wolfefa84d42009-05-18 16:42:12 +0200794 /* Find driver and parse its options */
bellardea2384d2004-08-01 21:59:26 +0000795 drv = bdrv_find_format(out_fmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900796 if (!drv) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100797 error_report("Unknown file format '%s'", out_fmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900798 ret = -1;
799 goto out;
800 }
balrog926c2d22007-10-31 01:11:44 +0000801
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900802 proto_drv = bdrv_find_protocol(out_filename);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900803 if (!proto_drv) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100804 error_report("Unknown protocol '%s'", out_filename);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900805 ret = -1;
806 goto out;
807 }
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900808
809 create_options = append_option_parameters(create_options,
810 drv->create_options);
811 create_options = append_option_parameters(create_options,
812 proto_drv->create_options);
Kevin Wolfdb08adf2009-06-04 15:39:38 +0200813
Kevin Wolfefa84d42009-05-18 16:42:12 +0200814 if (options) {
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900815 param = parse_option_parameters(options, create_options, param);
Kevin Wolfefa84d42009-05-18 16:42:12 +0200816 if (param == NULL) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100817 error_report("Invalid options for file format '%s'.", out_fmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900818 ret = -1;
819 goto out;
Kevin Wolfefa84d42009-05-18 16:42:12 +0200820 }
821 } else {
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900822 param = parse_option_parameters("", create_options, param);
Kevin Wolfefa84d42009-05-18 16:42:12 +0200823 }
824
825 set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
Jes Sorenseneec77d92010-12-07 17:44:34 +0100826 ret = add_old_style_options(out_fmt, param, out_baseimg, NULL);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900827 if (ret < 0) {
828 goto out;
829 }
Kevin Wolfefa84d42009-05-18 16:42:12 +0200830
Kevin Wolfa18953f2010-10-14 15:46:04 +0200831 /* Get backing file name if -o backing_file was used */
832 out_baseimg_param = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
833 if (out_baseimg_param) {
834 out_baseimg = out_baseimg_param->value.s;
835 }
836
Kevin Wolfefa84d42009-05-18 16:42:12 +0200837 /* Check if compression is supported */
Jes Sorenseneec77d92010-12-07 17:44:34 +0100838 if (compress) {
Kevin Wolfefa84d42009-05-18 16:42:12 +0200839 QEMUOptionParameter *encryption =
840 get_option_parameter(param, BLOCK_OPT_ENCRYPT);
Kevin Wolf41521fa2011-10-18 16:19:42 +0200841 QEMUOptionParameter *preallocation =
842 get_option_parameter(param, BLOCK_OPT_PREALLOC);
Kevin Wolfefa84d42009-05-18 16:42:12 +0200843
844 if (!drv->bdrv_write_compressed) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100845 error_report("Compression not supported for this file format");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900846 ret = -1;
847 goto out;
Kevin Wolfefa84d42009-05-18 16:42:12 +0200848 }
849
850 if (encryption && encryption->value.n) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100851 error_report("Compression and encryption not supported at "
852 "the same time");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900853 ret = -1;
854 goto out;
Kevin Wolfefa84d42009-05-18 16:42:12 +0200855 }
Kevin Wolf41521fa2011-10-18 16:19:42 +0200856
857 if (preallocation && preallocation->value.s
858 && strcmp(preallocation->value.s, "off"))
859 {
860 error_report("Compression and preallocation not supported at "
861 "the same time");
862 ret = -1;
863 goto out;
864 }
Kevin Wolfefa84d42009-05-18 16:42:12 +0200865 }
866
867 /* Create the new image */
868 ret = bdrv_create(drv, out_filename, param);
bellardea2384d2004-08-01 21:59:26 +0000869 if (ret < 0) {
870 if (ret == -ENOTSUP) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100871 error_report("Formatting not supported for file format '%s'",
872 out_fmt);
aurel326e9ea0c2009-04-15 14:42:46 +0000873 } else if (ret == -EFBIG) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100874 error_report("The image size is too large for file format '%s'",
875 out_fmt);
bellardea2384d2004-08-01 21:59:26 +0000876 } else {
Jes Sorensen15654a62010-12-16 14:31:53 +0100877 error_report("%s: error while converting %s: %s",
878 out_filename, out_fmt, strerror(-ret));
bellardea2384d2004-08-01 21:59:26 +0000879 }
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900880 goto out;
bellardea2384d2004-08-01 21:59:26 +0000881 }
ths3b46e622007-09-17 08:09:54 +0000882
Federico Simoncelli661a0f72011-06-20 12:48:19 -0400883 flags = BDRV_O_RDWR;
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100884 ret = bdrv_parse_cache_flags(cache, &flags);
Federico Simoncelli661a0f72011-06-20 12:48:19 -0400885 if (ret < 0) {
886 error_report("Invalid cache option: %s", cache);
887 return -1;
888 }
889
Daniel P. Berrangef0536bb2012-09-10 12:11:31 +0100890 out_bs = bdrv_new_open(out_filename, out_fmt, flags, true);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900891 if (!out_bs) {
892 ret = -1;
893 goto out;
894 }
bellardea2384d2004-08-01 21:59:26 +0000895
balrog926c2d22007-10-31 01:11:44 +0000896 bs_i = 0;
897 bs_offset = 0;
898 bdrv_get_geometry(bs[0], &bs_sectors);
Kevin Wolfbb1c0592011-08-08 14:09:12 +0200899 buf = qemu_blockalign(out_bs, IO_BUF_SIZE);
balrog926c2d22007-10-31 01:11:44 +0000900
Jes Sorenseneec77d92010-12-07 17:44:34 +0100901 if (compress) {
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900902 ret = bdrv_get_info(out_bs, &bdi);
903 if (ret < 0) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100904 error_report("could not get block driver info");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900905 goto out;
906 }
bellardfaea38e2006-08-05 21:31:00 +0000907 cluster_size = bdi.cluster_size;
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900908 if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100909 error_report("invalid cluster size");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900910 ret = -1;
911 goto out;
912 }
bellardea2384d2004-08-01 21:59:26 +0000913 cluster_sectors = cluster_size >> 9;
914 sector_num = 0;
Jes Sorensen6b837bc2011-03-30 14:16:25 +0200915
916 nb_sectors = total_sectors;
Kevin Wolf1f710492012-10-12 14:29:18 +0200917 if (nb_sectors != 0) {
918 local_progress = (float)100 /
919 (nb_sectors / MIN(nb_sectors, cluster_sectors));
920 }
Jes Sorensen6b837bc2011-03-30 14:16:25 +0200921
bellardea2384d2004-08-01 21:59:26 +0000922 for(;;) {
balrog926c2d22007-10-31 01:11:44 +0000923 int64_t bs_num;
924 int remainder;
925 uint8_t *buf2;
926
bellardea2384d2004-08-01 21:59:26 +0000927 nb_sectors = total_sectors - sector_num;
928 if (nb_sectors <= 0)
929 break;
930 if (nb_sectors >= cluster_sectors)
931 n = cluster_sectors;
932 else
933 n = nb_sectors;
balrog926c2d22007-10-31 01:11:44 +0000934
935 bs_num = sector_num - bs_offset;
936 assert (bs_num >= 0);
937 remainder = n;
938 buf2 = buf;
939 while (remainder > 0) {
940 int nlow;
941 while (bs_num == bs_sectors) {
942 bs_i++;
943 assert (bs_i < bs_n);
944 bs_offset += bs_sectors;
945 bdrv_get_geometry(bs[bs_i], &bs_sectors);
946 bs_num = 0;
Blue Swirl0bfcd592010-05-22 08:02:12 +0000947 /* printf("changing part: sector_num=%" PRId64 ", "
948 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
949 "\n", sector_num, bs_i, bs_offset, bs_sectors); */
balrog926c2d22007-10-31 01:11:44 +0000950 }
951 assert (bs_num < bs_sectors);
952
953 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;
954
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900955 ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow);
956 if (ret < 0) {
Stefan Hajnoczi3fba9d82011-08-17 17:41:09 +0100957 error_report("error while reading sector %" PRId64 ": %s",
958 bs_num, strerror(-ret));
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900959 goto out;
960 }
balrog926c2d22007-10-31 01:11:44 +0000961
962 buf2 += nlow * 512;
963 bs_num += nlow;
964
965 remainder -= nlow;
966 }
967 assert (remainder == 0);
968
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100969 if (n < cluster_sectors) {
bellardea2384d2004-08-01 21:59:26 +0000970 memset(buf + n * 512, 0, cluster_size - n * 512);
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100971 }
Stefan Hajnoczi1a6d39f2012-02-07 13:27:24 +0000972 if (!buffer_is_zero(buf, cluster_size)) {
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900973 ret = bdrv_write_compressed(out_bs, sector_num, buf,
974 cluster_sectors);
975 if (ret != 0) {
Stefan Hajnoczi3fba9d82011-08-17 17:41:09 +0100976 error_report("error while compressing sector %" PRId64
977 ": %s", sector_num, strerror(-ret));
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900978 goto out;
979 }
bellardea2384d2004-08-01 21:59:26 +0000980 }
981 sector_num += n;
Jes Sorensen6b837bc2011-03-30 14:16:25 +0200982 qemu_progress_print(local_progress, 100);
bellardea2384d2004-08-01 21:59:26 +0000983 }
bellardfaea38e2006-08-05 21:31:00 +0000984 /* signal EOF to align */
985 bdrv_write_compressed(out_bs, 0, NULL, 0);
bellardea2384d2004-08-01 21:59:26 +0000986 } else {
Kevin Wolff2feebb2010-04-14 17:30:35 +0200987 int has_zero_init = bdrv_has_zero_init(out_bs);
988
thsf58c7b32008-06-05 21:53:49 +0000989 sector_num = 0; // total number of sectors converted so far
Jes Sorensen6b837bc2011-03-30 14:16:25 +0200990 nb_sectors = total_sectors - sector_num;
Kevin Wolf1f710492012-10-12 14:29:18 +0200991 if (nb_sectors != 0) {
992 local_progress = (float)100 /
993 (nb_sectors / MIN(nb_sectors, IO_BUF_SIZE / 512));
994 }
Jes Sorensen6b837bc2011-03-30 14:16:25 +0200995
bellardea2384d2004-08-01 21:59:26 +0000996 for(;;) {
997 nb_sectors = total_sectors - sector_num;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100998 if (nb_sectors <= 0) {
bellardea2384d2004-08-01 21:59:26 +0000999 break;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001000 }
1001 if (nb_sectors >= (IO_BUF_SIZE / 512)) {
bellardea2384d2004-08-01 21:59:26 +00001002 n = (IO_BUF_SIZE / 512);
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001003 } else {
bellardea2384d2004-08-01 21:59:26 +00001004 n = nb_sectors;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001005 }
balrog926c2d22007-10-31 01:11:44 +00001006
1007 while (sector_num - bs_offset >= bs_sectors) {
1008 bs_i ++;
1009 assert (bs_i < bs_n);
1010 bs_offset += bs_sectors;
1011 bdrv_get_geometry(bs[bs_i], &bs_sectors);
Blue Swirl0bfcd592010-05-22 08:02:12 +00001012 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
1013 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
balrog926c2d22007-10-31 01:11:44 +00001014 sector_num, bs_i, bs_offset, bs_sectors); */
1015 }
1016
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001017 if (n > bs_offset + bs_sectors - sector_num) {
balrog926c2d22007-10-31 01:11:44 +00001018 n = bs_offset + bs_sectors - sector_num;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001019 }
balrog926c2d22007-10-31 01:11:44 +00001020
Kevin Wolff2feebb2010-04-14 17:30:35 +02001021 if (has_zero_init) {
Akkarit Sangpetchd0320442009-07-17 10:02:15 +02001022 /* If the output image is being created as a copy on write image,
1023 assume that sectors which are unallocated in the input image
1024 are present in both the output's and input's base images (no
1025 need to copy them). */
1026 if (out_baseimg) {
1027 if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
1028 n, &n1)) {
1029 sector_num += n1;
1030 continue;
1031 }
1032 /* The next 'n1' sectors are allocated in the input image. Copy
1033 only those as they may be followed by unallocated sectors. */
1034 n = n1;
aliguori93c65b42009-04-05 17:40:43 +00001035 }
aliguori93c65b42009-04-05 17:40:43 +00001036 } else {
1037 n1 = n;
thsf58c7b32008-06-05 21:53:49 +00001038 }
1039
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001040 ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
1041 if (ret < 0) {
Stefan Hajnoczi3fba9d82011-08-17 17:41:09 +01001042 error_report("error while reading sector %" PRId64 ": %s",
1043 sector_num - bs_offset, strerror(-ret));
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001044 goto out;
1045 }
bellardea2384d2004-08-01 21:59:26 +00001046 /* NOTE: at the same time we convert, we do not write zero
1047 sectors to have a chance to compress the image. Ideally, we
1048 should add a specific call to have the info to go faster */
1049 buf1 = buf;
1050 while (n > 0) {
thsf58c7b32008-06-05 21:53:49 +00001051 /* If the output image is being created as a copy on write image,
1052 copy all sectors even the ones containing only NUL bytes,
aliguori93c65b42009-04-05 17:40:43 +00001053 because they may differ from the sectors in the base image.
1054
1055 If the output is to a host device, we also write out
1056 sectors that are entirely 0, since whatever data was
1057 already there is garbage, not 0s. */
Kevin Wolff2feebb2010-04-14 17:30:35 +02001058 if (!has_zero_init || out_baseimg ||
Kevin Wolfa22f1232011-08-26 15:27:13 +02001059 is_allocated_sectors_min(buf1, n, &n1, min_sparse)) {
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001060 ret = bdrv_write(out_bs, sector_num, buf1, n1);
1061 if (ret < 0) {
Stefan Hajnoczi3fba9d82011-08-17 17:41:09 +01001062 error_report("error while writing sector %" PRId64
1063 ": %s", sector_num, strerror(-ret));
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001064 goto out;
1065 }
bellardea2384d2004-08-01 21:59:26 +00001066 }
1067 sector_num += n1;
1068 n -= n1;
1069 buf1 += n1 * 512;
1070 }
Jes Sorensen6b837bc2011-03-30 14:16:25 +02001071 qemu_progress_print(local_progress, 100);
bellardea2384d2004-08-01 21:59:26 +00001072 }
1073 }
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001074out:
Jes Sorensen6b837bc2011-03-30 14:16:25 +02001075 qemu_progress_end();
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001076 free_option_parameters(create_options);
1077 free_option_parameters(param);
Kevin Wolfbb1c0592011-08-08 14:09:12 +02001078 qemu_vfree(buf);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001079 if (out_bs) {
1080 bdrv_delete(out_bs);
1081 }
Jes Sorensen31ca34b2010-12-06 15:25:36 +01001082 if (bs) {
1083 for (bs_i = 0; bs_i < bs_n; bs_i++) {
1084 if (bs[bs_i]) {
1085 bdrv_delete(bs[bs_i]);
1086 }
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001087 }
Anthony Liguori7267c092011-08-20 22:09:37 -05001088 g_free(bs);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001089 }
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001090 if (ret) {
1091 return 1;
1092 }
bellardea2384d2004-08-01 21:59:26 +00001093 return 0;
1094}
1095
bellard57d1a2b2004-08-03 21:15:11 +00001096
bellardfaea38e2006-08-05 21:31:00 +00001097static void dump_snapshots(BlockDriverState *bs)
1098{
1099 QEMUSnapshotInfo *sn_tab, *sn;
1100 int nb_sns, i;
1101 char buf[256];
1102
1103 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1104 if (nb_sns <= 0)
1105 return;
1106 printf("Snapshot list:\n");
1107 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
1108 for(i = 0; i < nb_sns; i++) {
1109 sn = &sn_tab[i];
1110 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
1111 }
Anthony Liguori7267c092011-08-20 22:09:37 -05001112 g_free(sn_tab);
bellardfaea38e2006-08-05 21:31:00 +00001113}
1114
Stefan Hajnoczi9699bf02012-10-17 14:02:31 +02001115static void dump_json_image_info_list(ImageInfoList *list)
1116{
1117 Error *errp = NULL;
1118 QString *str;
1119 QmpOutputVisitor *ov = qmp_output_visitor_new();
1120 QObject *obj;
1121 visit_type_ImageInfoList(qmp_output_get_visitor(ov),
1122 &list, NULL, &errp);
1123 obj = qmp_output_get_qobject(ov);
1124 str = qobject_to_json_pretty(obj);
1125 assert(str != NULL);
1126 printf("%s\n", qstring_get_str(str));
1127 qobject_decref(obj);
1128 qmp_output_visitor_cleanup(ov);
1129 QDECREF(str);
1130}
1131
Benoît Canetc054b3f2012-09-05 13:09:02 +02001132static void collect_snapshots(BlockDriverState *bs , ImageInfo *info)
bellardea2384d2004-08-01 21:59:26 +00001133{
Benoît Canetc054b3f2012-09-05 13:09:02 +02001134 int i, sn_count;
1135 QEMUSnapshotInfo *sn_tab = NULL;
1136 SnapshotInfoList *info_list, *cur_item = NULL;
1137 sn_count = bdrv_snapshot_list(bs, &sn_tab);
1138
1139 for (i = 0; i < sn_count; i++) {
1140 info->has_snapshots = true;
1141 info_list = g_new0(SnapshotInfoList, 1);
1142
1143 info_list->value = g_new0(SnapshotInfo, 1);
1144 info_list->value->id = g_strdup(sn_tab[i].id_str);
1145 info_list->value->name = g_strdup(sn_tab[i].name);
1146 info_list->value->vm_state_size = sn_tab[i].vm_state_size;
1147 info_list->value->date_sec = sn_tab[i].date_sec;
1148 info_list->value->date_nsec = sn_tab[i].date_nsec;
1149 info_list->value->vm_clock_sec = sn_tab[i].vm_clock_nsec / 1000000000;
1150 info_list->value->vm_clock_nsec = sn_tab[i].vm_clock_nsec % 1000000000;
1151
1152 /* XXX: waiting for the qapi to support qemu-queue.h types */
1153 if (!cur_item) {
1154 info->snapshots = cur_item = info_list;
1155 } else {
1156 cur_item->next = info_list;
1157 cur_item = info_list;
1158 }
1159
1160 }
1161
1162 g_free(sn_tab);
1163}
1164
1165static void dump_json_image_info(ImageInfo *info)
1166{
1167 Error *errp = NULL;
1168 QString *str;
1169 QmpOutputVisitor *ov = qmp_output_visitor_new();
1170 QObject *obj;
1171 visit_type_ImageInfo(qmp_output_get_visitor(ov),
1172 &info, NULL, &errp);
1173 obj = qmp_output_get_qobject(ov);
1174 str = qobject_to_json_pretty(obj);
1175 assert(str != NULL);
1176 printf("%s\n", qstring_get_str(str));
1177 qobject_decref(obj);
1178 qmp_output_visitor_cleanup(ov);
1179 QDECREF(str);
1180}
1181
1182static void collect_image_info(BlockDriverState *bs,
1183 ImageInfo *info,
1184 const char *filename,
1185 const char *fmt)
1186{
ths96b8f132007-12-17 01:35:20 +00001187 uint64_t total_sectors;
bellard93b6b2a2006-08-01 15:51:11 +00001188 char backing_filename[1024];
1189 char backing_filename2[1024];
bellardfaea38e2006-08-05 21:31:00 +00001190 BlockDriverInfo bdi;
bellardea2384d2004-08-01 21:59:26 +00001191
Benoît Canetc054b3f2012-09-05 13:09:02 +02001192 bdrv_get_geometry(bs, &total_sectors);
1193
1194 info->filename = g_strdup(filename);
1195 info->format = g_strdup(bdrv_get_format_name(bs));
1196 info->virtual_size = total_sectors * 512;
1197 info->actual_size = bdrv_get_allocated_file_size(bs);
1198 info->has_actual_size = info->actual_size >= 0;
1199 if (bdrv_is_encrypted(bs)) {
1200 info->encrypted = true;
1201 info->has_encrypted = true;
1202 }
1203 if (bdrv_get_info(bs, &bdi) >= 0) {
1204 if (bdi.cluster_size != 0) {
1205 info->cluster_size = bdi.cluster_size;
1206 info->has_cluster_size = true;
1207 }
1208 info->dirty_flag = bdi.is_dirty;
1209 info->has_dirty_flag = true;
1210 }
1211 bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
1212 if (backing_filename[0] != '\0') {
1213 info->backing_filename = g_strdup(backing_filename);
1214 info->has_backing_filename = true;
1215 bdrv_get_full_backing_filename(bs, backing_filename2,
1216 sizeof(backing_filename2));
1217
1218 if (strcmp(backing_filename, backing_filename2) != 0) {
1219 info->full_backing_filename =
1220 g_strdup(backing_filename2);
1221 info->has_full_backing_filename = true;
1222 }
1223
1224 if (bs->backing_format[0]) {
1225 info->backing_filename_format = g_strdup(bs->backing_format);
1226 info->has_backing_filename_format = true;
1227 }
1228 }
1229}
1230
1231static void dump_human_image_info(ImageInfo *info)
1232{
1233 char size_buf[128], dsize_buf[128];
1234 if (!info->has_actual_size) {
1235 snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
1236 } else {
1237 get_human_readable_size(dsize_buf, sizeof(dsize_buf),
1238 info->actual_size);
1239 }
1240 get_human_readable_size(size_buf, sizeof(size_buf), info->virtual_size);
1241 printf("image: %s\n"
1242 "file format: %s\n"
1243 "virtual size: %s (%" PRId64 " bytes)\n"
1244 "disk size: %s\n",
1245 info->filename, info->format, size_buf,
1246 info->virtual_size,
1247 dsize_buf);
1248
1249 if (info->has_encrypted && info->encrypted) {
1250 printf("encrypted: yes\n");
1251 }
1252
1253 if (info->has_cluster_size) {
1254 printf("cluster_size: %" PRId64 "\n", info->cluster_size);
1255 }
1256
1257 if (info->has_dirty_flag && info->dirty_flag) {
1258 printf("cleanly shut down: no\n");
1259 }
1260
1261 if (info->has_backing_filename) {
1262 printf("backing file: %s", info->backing_filename);
1263 if (info->has_full_backing_filename) {
1264 printf(" (actual path: %s)", info->full_backing_filename);
1265 }
1266 putchar('\n');
1267 if (info->has_backing_filename_format) {
1268 printf("backing file format: %s\n", info->backing_filename_format);
1269 }
1270 }
Stefan Hajnoczi9699bf02012-10-17 14:02:31 +02001271
1272 if (info->has_snapshots) {
1273 SnapshotInfoList *elem;
1274 char buf[256];
1275
1276 printf("Snapshot list:\n");
1277 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
1278
1279 /* Ideally bdrv_snapshot_dump() would operate on SnapshotInfoList but
1280 * we convert to the block layer's native QEMUSnapshotInfo for now.
1281 */
1282 for (elem = info->snapshots; elem; elem = elem->next) {
1283 QEMUSnapshotInfo sn = {
1284 .vm_state_size = elem->value->vm_state_size,
1285 .date_sec = elem->value->date_sec,
1286 .date_nsec = elem->value->date_nsec,
1287 .vm_clock_nsec = elem->value->vm_clock_sec * 1000000000ULL +
1288 elem->value->vm_clock_nsec,
1289 };
1290
1291 pstrcpy(sn.id_str, sizeof(sn.id_str), elem->value->id);
1292 pstrcpy(sn.name, sizeof(sn.name), elem->value->name);
1293 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), &sn));
1294 }
1295 }
Benoît Canetc054b3f2012-09-05 13:09:02 +02001296}
1297
Stefan Hajnoczi9699bf02012-10-17 14:02:31 +02001298static void dump_human_image_info_list(ImageInfoList *list)
1299{
1300 ImageInfoList *elem;
1301 bool delim = false;
1302
1303 for (elem = list; elem; elem = elem->next) {
1304 if (delim) {
1305 printf("\n");
1306 }
1307 delim = true;
1308
1309 dump_human_image_info(elem->value);
1310 }
1311}
1312
1313static gboolean str_equal_func(gconstpointer a, gconstpointer b)
1314{
1315 return strcmp(a, b) == 0;
1316}
1317
1318/**
1319 * Open an image file chain and return an ImageInfoList
1320 *
1321 * @filename: topmost image filename
1322 * @fmt: topmost image format (may be NULL to autodetect)
1323 * @chain: true - enumerate entire backing file chain
1324 * false - only topmost image file
1325 *
1326 * Returns a list of ImageInfo objects or NULL if there was an error opening an
1327 * image file. If there was an error a message will have been printed to
1328 * stderr.
1329 */
1330static ImageInfoList *collect_image_info_list(const char *filename,
1331 const char *fmt,
1332 bool chain)
1333{
1334 ImageInfoList *head = NULL;
1335 ImageInfoList **last = &head;
1336 GHashTable *filenames;
1337
1338 filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL);
1339
1340 while (filename) {
1341 BlockDriverState *bs;
1342 ImageInfo *info;
1343 ImageInfoList *elem;
1344
1345 if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) {
1346 error_report("Backing file '%s' creates an infinite loop.",
1347 filename);
1348 goto err;
1349 }
1350 g_hash_table_insert(filenames, (gpointer)filename, NULL);
1351
1352 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING,
1353 false);
1354 if (!bs) {
1355 goto err;
1356 }
1357
1358 info = g_new0(ImageInfo, 1);
1359 collect_image_info(bs, info, filename, fmt);
1360 collect_snapshots(bs, info);
1361
1362 elem = g_new0(ImageInfoList, 1);
1363 elem->value = info;
1364 *last = elem;
1365 last = &elem->next;
1366
1367 bdrv_delete(bs);
1368
1369 filename = fmt = NULL;
1370 if (chain) {
1371 if (info->has_full_backing_filename) {
1372 filename = info->full_backing_filename;
1373 } else if (info->has_backing_filename) {
1374 filename = info->backing_filename;
1375 }
1376 if (info->has_backing_filename_format) {
1377 fmt = info->backing_filename_format;
1378 }
1379 }
1380 }
1381 g_hash_table_destroy(filenames);
1382 return head;
1383
1384err:
1385 qapi_free_ImageInfoList(head);
1386 g_hash_table_destroy(filenames);
1387 return NULL;
1388}
1389
1390enum {
1391 OPTION_OUTPUT = 256,
1392 OPTION_BACKING_CHAIN = 257,
1393};
Benoît Canetc054b3f2012-09-05 13:09:02 +02001394
1395typedef enum OutputFormat {
1396 OFORMAT_JSON,
1397 OFORMAT_HUMAN,
1398} OutputFormat;
1399
1400static int img_info(int argc, char **argv)
1401{
1402 int c;
1403 OutputFormat output_format = OFORMAT_HUMAN;
Stefan Hajnoczi9699bf02012-10-17 14:02:31 +02001404 bool chain = false;
Benoît Canetc054b3f2012-09-05 13:09:02 +02001405 const char *filename, *fmt, *output;
Stefan Hajnoczi9699bf02012-10-17 14:02:31 +02001406 ImageInfoList *list;
Benoît Canetc054b3f2012-09-05 13:09:02 +02001407
bellardea2384d2004-08-01 21:59:26 +00001408 fmt = NULL;
Benoît Canetc054b3f2012-09-05 13:09:02 +02001409 output = NULL;
bellardea2384d2004-08-01 21:59:26 +00001410 for(;;) {
Benoît Canetc054b3f2012-09-05 13:09:02 +02001411 int option_index = 0;
1412 static const struct option long_options[] = {
1413 {"help", no_argument, 0, 'h'},
1414 {"format", required_argument, 0, 'f'},
1415 {"output", required_argument, 0, OPTION_OUTPUT},
Stefan Hajnoczi9699bf02012-10-17 14:02:31 +02001416 {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN},
Benoît Canetc054b3f2012-09-05 13:09:02 +02001417 {0, 0, 0, 0}
1418 };
1419 c = getopt_long(argc, argv, "f:h",
1420 long_options, &option_index);
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001421 if (c == -1) {
bellardea2384d2004-08-01 21:59:26 +00001422 break;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001423 }
bellardea2384d2004-08-01 21:59:26 +00001424 switch(c) {
Jes Sorensenef873942010-12-06 15:25:40 +01001425 case '?':
bellardea2384d2004-08-01 21:59:26 +00001426 case 'h':
1427 help();
1428 break;
1429 case 'f':
1430 fmt = optarg;
1431 break;
Benoît Canetc054b3f2012-09-05 13:09:02 +02001432 case OPTION_OUTPUT:
1433 output = optarg;
1434 break;
Stefan Hajnoczi9699bf02012-10-17 14:02:31 +02001435 case OPTION_BACKING_CHAIN:
1436 chain = true;
1437 break;
bellardea2384d2004-08-01 21:59:26 +00001438 }
1439 }
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001440 if (optind >= argc) {
bellardea2384d2004-08-01 21:59:26 +00001441 help();
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001442 }
bellardea2384d2004-08-01 21:59:26 +00001443 filename = argv[optind++];
1444
Benoît Canetc054b3f2012-09-05 13:09:02 +02001445 if (output && !strcmp(output, "json")) {
1446 output_format = OFORMAT_JSON;
1447 } else if (output && !strcmp(output, "human")) {
1448 output_format = OFORMAT_HUMAN;
1449 } else if (output) {
1450 error_report("--output must be used with human or json as argument.");
1451 return 1;
1452 }
1453
Stefan Hajnoczi9699bf02012-10-17 14:02:31 +02001454 list = collect_image_info_list(filename, fmt, chain);
1455 if (!list) {
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001456 return 1;
1457 }
Benoît Canetc054b3f2012-09-05 13:09:02 +02001458
Benoît Canetc054b3f2012-09-05 13:09:02 +02001459 switch (output_format) {
1460 case OFORMAT_HUMAN:
Stefan Hajnoczi9699bf02012-10-17 14:02:31 +02001461 dump_human_image_info_list(list);
Benoît Canetc054b3f2012-09-05 13:09:02 +02001462 break;
1463 case OFORMAT_JSON:
Stefan Hajnoczi9699bf02012-10-17 14:02:31 +02001464 if (chain) {
1465 dump_json_image_info_list(list);
1466 } else {
1467 dump_json_image_info(list->value);
1468 }
Benoît Canetc054b3f2012-09-05 13:09:02 +02001469 break;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001470 }
Benoît Canetc054b3f2012-09-05 13:09:02 +02001471
Stefan Hajnoczi9699bf02012-10-17 14:02:31 +02001472 qapi_free_ImageInfoList(list);
bellardea2384d2004-08-01 21:59:26 +00001473 return 0;
1474}
1475
aliguorif7b4a942009-01-07 17:40:15 +00001476#define SNAPSHOT_LIST 1
1477#define SNAPSHOT_CREATE 2
1478#define SNAPSHOT_APPLY 3
1479#define SNAPSHOT_DELETE 4
1480
Stuart Brady153859b2009-06-07 00:42:17 +01001481static int img_snapshot(int argc, char **argv)
aliguorif7b4a942009-01-07 17:40:15 +00001482{
1483 BlockDriverState *bs;
1484 QEMUSnapshotInfo sn;
1485 char *filename, *snapshot_name = NULL;
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001486 int c, ret = 0, bdrv_oflags;
aliguorif7b4a942009-01-07 17:40:15 +00001487 int action = 0;
1488 qemu_timeval tv;
1489
Kevin Wolf710da702011-01-10 12:33:02 +01001490 bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
aliguorif7b4a942009-01-07 17:40:15 +00001491 /* Parse commandline parameters */
1492 for(;;) {
1493 c = getopt(argc, argv, "la:c:d:h");
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001494 if (c == -1) {
aliguorif7b4a942009-01-07 17:40:15 +00001495 break;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001496 }
aliguorif7b4a942009-01-07 17:40:15 +00001497 switch(c) {
Jes Sorensenef873942010-12-06 15:25:40 +01001498 case '?':
aliguorif7b4a942009-01-07 17:40:15 +00001499 case 'h':
1500 help();
Stuart Brady153859b2009-06-07 00:42:17 +01001501 return 0;
aliguorif7b4a942009-01-07 17:40:15 +00001502 case 'l':
1503 if (action) {
1504 help();
Stuart Brady153859b2009-06-07 00:42:17 +01001505 return 0;
aliguorif7b4a942009-01-07 17:40:15 +00001506 }
1507 action = SNAPSHOT_LIST;
Naphtali Spreif5edb012010-01-17 16:48:13 +02001508 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
aliguorif7b4a942009-01-07 17:40:15 +00001509 break;
1510 case 'a':
1511 if (action) {
1512 help();
Stuart Brady153859b2009-06-07 00:42:17 +01001513 return 0;
aliguorif7b4a942009-01-07 17:40:15 +00001514 }
1515 action = SNAPSHOT_APPLY;
1516 snapshot_name = optarg;
1517 break;
1518 case 'c':
1519 if (action) {
1520 help();
Stuart Brady153859b2009-06-07 00:42:17 +01001521 return 0;
aliguorif7b4a942009-01-07 17:40:15 +00001522 }
1523 action = SNAPSHOT_CREATE;
1524 snapshot_name = optarg;
1525 break;
1526 case 'd':
1527 if (action) {
1528 help();
Stuart Brady153859b2009-06-07 00:42:17 +01001529 return 0;
aliguorif7b4a942009-01-07 17:40:15 +00001530 }
1531 action = SNAPSHOT_DELETE;
1532 snapshot_name = optarg;
1533 break;
1534 }
1535 }
1536
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001537 if (optind >= argc) {
aliguorif7b4a942009-01-07 17:40:15 +00001538 help();
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001539 }
aliguorif7b4a942009-01-07 17:40:15 +00001540 filename = argv[optind++];
1541
1542 /* Open the image */
Daniel P. Berrangef0536bb2012-09-10 12:11:31 +01001543 bs = bdrv_new_open(filename, NULL, bdrv_oflags, true);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001544 if (!bs) {
1545 return 1;
1546 }
aliguorif7b4a942009-01-07 17:40:15 +00001547
1548 /* Perform the requested action */
1549 switch(action) {
1550 case SNAPSHOT_LIST:
1551 dump_snapshots(bs);
1552 break;
1553
1554 case SNAPSHOT_CREATE:
1555 memset(&sn, 0, sizeof(sn));
1556 pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
1557
1558 qemu_gettimeofday(&tv);
1559 sn.date_sec = tv.tv_sec;
1560 sn.date_nsec = tv.tv_usec * 1000;
1561
1562 ret = bdrv_snapshot_create(bs, &sn);
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001563 if (ret) {
Jes Sorensen15654a62010-12-16 14:31:53 +01001564 error_report("Could not create snapshot '%s': %d (%s)",
aliguorif7b4a942009-01-07 17:40:15 +00001565 snapshot_name, ret, strerror(-ret));
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001566 }
aliguorif7b4a942009-01-07 17:40:15 +00001567 break;
1568
1569 case SNAPSHOT_APPLY:
1570 ret = bdrv_snapshot_goto(bs, snapshot_name);
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001571 if (ret) {
Jes Sorensen15654a62010-12-16 14:31:53 +01001572 error_report("Could not apply snapshot '%s': %d (%s)",
aliguorif7b4a942009-01-07 17:40:15 +00001573 snapshot_name, ret, strerror(-ret));
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001574 }
aliguorif7b4a942009-01-07 17:40:15 +00001575 break;
1576
1577 case SNAPSHOT_DELETE:
1578 ret = bdrv_snapshot_delete(bs, snapshot_name);
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001579 if (ret) {
Jes Sorensen15654a62010-12-16 14:31:53 +01001580 error_report("Could not delete snapshot '%s': %d (%s)",
aliguorif7b4a942009-01-07 17:40:15 +00001581 snapshot_name, ret, strerror(-ret));
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001582 }
aliguorif7b4a942009-01-07 17:40:15 +00001583 break;
1584 }
1585
1586 /* Cleanup */
1587 bdrv_delete(bs);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001588 if (ret) {
1589 return 1;
1590 }
Stuart Brady153859b2009-06-07 00:42:17 +01001591 return 0;
aliguorif7b4a942009-01-07 17:40:15 +00001592}
1593
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001594static int img_rebase(int argc, char **argv)
1595{
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001596 BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
Stefan Hajnoczif163d072010-04-13 10:29:34 +01001597 BlockDriver *old_backing_drv, *new_backing_drv;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001598 char *filename;
Federico Simoncelli661a0f72011-06-20 12:48:19 -04001599 const char *fmt, *cache, *out_basefmt, *out_baseimg;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001600 int c, flags, ret;
1601 int unsafe = 0;
Jes Sorensen6b837bc2011-03-30 14:16:25 +02001602 int progress = 0;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001603
1604 /* Parse commandline parameters */
Kevin Wolfe53dbee2010-03-02 12:14:31 +01001605 fmt = NULL;
Federico Simoncelli661a0f72011-06-20 12:48:19 -04001606 cache = BDRV_DEFAULT_CACHE;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001607 out_baseimg = NULL;
1608 out_basefmt = NULL;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001609 for(;;) {
Federico Simoncelli661a0f72011-06-20 12:48:19 -04001610 c = getopt(argc, argv, "uhf:F:b:pt:");
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001611 if (c == -1) {
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001612 break;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001613 }
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001614 switch(c) {
Jes Sorensenef873942010-12-06 15:25:40 +01001615 case '?':
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001616 case 'h':
1617 help();
1618 return 0;
Kevin Wolfe53dbee2010-03-02 12:14:31 +01001619 case 'f':
1620 fmt = optarg;
1621 break;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001622 case 'F':
1623 out_basefmt = optarg;
1624 break;
1625 case 'b':
1626 out_baseimg = optarg;
1627 break;
1628 case 'u':
1629 unsafe = 1;
1630 break;
Jes Sorensen6b837bc2011-03-30 14:16:25 +02001631 case 'p':
1632 progress = 1;
1633 break;
Federico Simoncelli661a0f72011-06-20 12:48:19 -04001634 case 't':
1635 cache = optarg;
1636 break;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001637 }
1638 }
1639
Anthony Liguori9a9d9db2011-04-13 15:51:47 +01001640 if ((optind >= argc) || (!unsafe && !out_baseimg)) {
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001641 help();
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001642 }
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001643 filename = argv[optind++];
1644
Jes Sorensen6b837bc2011-03-30 14:16:25 +02001645 qemu_progress_init(progress, 2.0);
1646 qemu_progress_print(0, 100);
1647
Federico Simoncelli661a0f72011-06-20 12:48:19 -04001648 flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +01001649 ret = bdrv_parse_cache_flags(cache, &flags);
Federico Simoncelli661a0f72011-06-20 12:48:19 -04001650 if (ret < 0) {
1651 error_report("Invalid cache option: %s", cache);
1652 return -1;
1653 }
1654
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001655 /*
1656 * Open the images.
1657 *
1658 * Ignore the old backing file for unsafe rebase in case we want to correct
1659 * the reference to a renamed or moved backing file.
1660 */
Daniel P. Berrangef0536bb2012-09-10 12:11:31 +01001661 bs = bdrv_new_open(filename, fmt, flags, true);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001662 if (!bs) {
1663 return 1;
1664 }
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001665
1666 /* Find the right drivers for the backing files */
1667 old_backing_drv = NULL;
1668 new_backing_drv = NULL;
1669
1670 if (!unsafe && bs->backing_format[0] != '\0') {
1671 old_backing_drv = bdrv_find_format(bs->backing_format);
1672 if (old_backing_drv == NULL) {
Jes Sorensen15654a62010-12-16 14:31:53 +01001673 error_report("Invalid format name: '%s'", bs->backing_format);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001674 ret = -1;
1675 goto out;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001676 }
1677 }
1678
1679 if (out_basefmt != NULL) {
1680 new_backing_drv = bdrv_find_format(out_basefmt);
1681 if (new_backing_drv == NULL) {
Jes Sorensen15654a62010-12-16 14:31:53 +01001682 error_report("Invalid format name: '%s'", out_basefmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001683 ret = -1;
1684 goto out;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001685 }
1686 }
1687
1688 /* For safe rebasing we need to compare old and new backing file */
1689 if (unsafe) {
1690 /* Make the compiler happy */
1691 bs_old_backing = NULL;
1692 bs_new_backing = NULL;
1693 } else {
1694 char backing_name[1024];
1695
1696 bs_old_backing = bdrv_new("old_backing");
1697 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001698 ret = bdrv_open(bs_old_backing, backing_name, BDRV_O_FLAGS,
1699 old_backing_drv);
1700 if (ret) {
Jes Sorensen15654a62010-12-16 14:31:53 +01001701 error_report("Could not open old backing file '%s'", backing_name);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001702 goto out;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001703 }
Alex Bligha6166732012-10-16 13:46:18 +01001704 if (out_baseimg[0]) {
1705 bs_new_backing = bdrv_new("new_backing");
1706 ret = bdrv_open(bs_new_backing, out_baseimg, BDRV_O_FLAGS,
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001707 new_backing_drv);
Alex Bligha6166732012-10-16 13:46:18 +01001708 if (ret) {
1709 error_report("Could not open new backing file '%s'",
1710 out_baseimg);
1711 goto out;
1712 }
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001713 }
1714 }
1715
1716 /*
1717 * Check each unallocated cluster in the COW file. If it is unallocated,
1718 * accesses go to the backing file. We must therefore compare this cluster
1719 * in the old and new backing file, and if they differ we need to copy it
1720 * from the old backing file into the COW file.
1721 *
1722 * If qemu-img crashes during this step, no harm is done. The content of
1723 * the image is the same as the original one at any time.
1724 */
1725 if (!unsafe) {
1726 uint64_t num_sectors;
Kevin Wolf87a1b3e2011-12-07 12:42:10 +01001727 uint64_t old_backing_num_sectors;
Alex Bligha6166732012-10-16 13:46:18 +01001728 uint64_t new_backing_num_sectors = 0;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001729 uint64_t sector;
Kevin Wolfcc60e322010-04-29 14:47:48 +02001730 int n;
TeLeMand6771bf2010-02-08 16:20:00 +08001731 uint8_t * buf_old;
1732 uint8_t * buf_new;
Kevin Wolf1f710492012-10-12 14:29:18 +02001733 float local_progress = 0;
TeLeMand6771bf2010-02-08 16:20:00 +08001734
Kevin Wolfbb1c0592011-08-08 14:09:12 +02001735 buf_old = qemu_blockalign(bs, IO_BUF_SIZE);
1736 buf_new = qemu_blockalign(bs, IO_BUF_SIZE);
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001737
1738 bdrv_get_geometry(bs, &num_sectors);
Kevin Wolf87a1b3e2011-12-07 12:42:10 +01001739 bdrv_get_geometry(bs_old_backing, &old_backing_num_sectors);
Alex Bligha6166732012-10-16 13:46:18 +01001740 if (bs_new_backing) {
1741 bdrv_get_geometry(bs_new_backing, &new_backing_num_sectors);
1742 }
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001743
Kevin Wolf1f710492012-10-12 14:29:18 +02001744 if (num_sectors != 0) {
1745 local_progress = (float)100 /
1746 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
1747 }
1748
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001749 for (sector = 0; sector < num_sectors; sector += n) {
1750
1751 /* How many sectors can we handle with the next read? */
1752 if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
1753 n = (IO_BUF_SIZE / 512);
1754 } else {
1755 n = num_sectors - sector;
1756 }
1757
1758 /* If the cluster is allocated, we don't need to take action */
Kevin Wolfcc60e322010-04-29 14:47:48 +02001759 ret = bdrv_is_allocated(bs, sector, n, &n);
1760 if (ret) {
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001761 continue;
1762 }
1763
Kevin Wolf87a1b3e2011-12-07 12:42:10 +01001764 /*
1765 * Read old and new backing file and take into consideration that
1766 * backing files may be smaller than the COW image.
1767 */
1768 if (sector >= old_backing_num_sectors) {
1769 memset(buf_old, 0, n * BDRV_SECTOR_SIZE);
1770 } else {
1771 if (sector + n > old_backing_num_sectors) {
1772 n = old_backing_num_sectors - sector;
1773 }
1774
1775 ret = bdrv_read(bs_old_backing, sector, buf_old, n);
1776 if (ret < 0) {
1777 error_report("error while reading from old backing file");
1778 goto out;
1779 }
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001780 }
Kevin Wolf87a1b3e2011-12-07 12:42:10 +01001781
Alex Bligha6166732012-10-16 13:46:18 +01001782 if (sector >= new_backing_num_sectors || !bs_new_backing) {
Kevin Wolf87a1b3e2011-12-07 12:42:10 +01001783 memset(buf_new, 0, n * BDRV_SECTOR_SIZE);
1784 } else {
1785 if (sector + n > new_backing_num_sectors) {
1786 n = new_backing_num_sectors - sector;
1787 }
1788
1789 ret = bdrv_read(bs_new_backing, sector, buf_new, n);
1790 if (ret < 0) {
1791 error_report("error while reading from new backing file");
1792 goto out;
1793 }
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001794 }
1795
1796 /* If they differ, we need to write to the COW file */
1797 uint64_t written = 0;
1798
1799 while (written < n) {
1800 int pnum;
1801
1802 if (compare_sectors(buf_old + written * 512,
Kevin Wolf60b1bd42010-02-17 12:32:59 +01001803 buf_new + written * 512, n - written, &pnum))
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001804 {
1805 ret = bdrv_write(bs, sector + written,
1806 buf_old + written * 512, pnum);
1807 if (ret < 0) {
Jes Sorensen15654a62010-12-16 14:31:53 +01001808 error_report("Error while writing to COW image: %s",
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001809 strerror(-ret));
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001810 goto out;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001811 }
1812 }
1813
1814 written += pnum;
1815 }
Jes Sorensen6b837bc2011-03-30 14:16:25 +02001816 qemu_progress_print(local_progress, 100);
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001817 }
TeLeMand6771bf2010-02-08 16:20:00 +08001818
Kevin Wolfbb1c0592011-08-08 14:09:12 +02001819 qemu_vfree(buf_old);
1820 qemu_vfree(buf_new);
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001821 }
1822
1823 /*
1824 * Change the backing file. All clusters that are different from the old
1825 * backing file are overwritten in the COW file now, so the visible content
1826 * doesn't change when we switch the backing file.
1827 */
Alex Bligha6166732012-10-16 13:46:18 +01001828 if (out_baseimg && *out_baseimg) {
1829 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
1830 } else {
1831 ret = bdrv_change_backing_file(bs, NULL, NULL);
1832 }
1833
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001834 if (ret == -ENOSPC) {
Jes Sorensen15654a62010-12-16 14:31:53 +01001835 error_report("Could not change the backing file to '%s': No "
1836 "space left in the file header", out_baseimg);
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001837 } else if (ret < 0) {
Jes Sorensen15654a62010-12-16 14:31:53 +01001838 error_report("Could not change the backing file to '%s': %s",
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001839 out_baseimg, strerror(-ret));
1840 }
1841
Jes Sorensen6b837bc2011-03-30 14:16:25 +02001842 qemu_progress_print(100, 0);
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001843 /*
1844 * TODO At this point it is possible to check if any clusters that are
1845 * allocated in the COW file are the same in the backing file. If so, they
1846 * could be dropped from the COW file. Don't do this before switching the
1847 * backing file, in case of a crash this would lead to corruption.
1848 */
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001849out:
Jes Sorensen6b837bc2011-03-30 14:16:25 +02001850 qemu_progress_end();
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001851 /* Cleanup */
1852 if (!unsafe) {
Kevin Wolfeb863ad2011-03-31 12:39:51 +02001853 if (bs_old_backing != NULL) {
1854 bdrv_delete(bs_old_backing);
1855 }
1856 if (bs_new_backing != NULL) {
1857 bdrv_delete(bs_new_backing);
1858 }
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001859 }
1860
1861 bdrv_delete(bs);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001862 if (ret) {
1863 return 1;
1864 }
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01001865 return 0;
1866}
1867
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001868static int img_resize(int argc, char **argv)
1869{
1870 int c, ret, relative;
1871 const char *filename, *fmt, *size;
1872 int64_t n, total_size;
Jes Sorensen2a819982010-12-06 17:08:31 +01001873 BlockDriverState *bs = NULL;
Dong Xu Wang20caf0f2012-08-06 10:18:42 +08001874 QemuOpts *param;
1875 static QemuOptsList resize_options = {
1876 .name = "resize_options",
1877 .head = QTAILQ_HEAD_INITIALIZER(resize_options.head),
1878 .desc = {
1879 {
1880 .name = BLOCK_OPT_SIZE,
1881 .type = QEMU_OPT_SIZE,
1882 .help = "Virtual disk size"
1883 }, {
1884 /* end of list */
1885 }
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001886 },
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001887 };
1888
Kevin Wolfe80fec72011-04-29 10:58:12 +02001889 /* Remove size from argv manually so that negative numbers are not treated
1890 * as options by getopt. */
1891 if (argc < 3) {
1892 help();
1893 return 1;
1894 }
1895
1896 size = argv[--argc];
1897
1898 /* Parse getopt arguments */
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001899 fmt = NULL;
1900 for(;;) {
1901 c = getopt(argc, argv, "f:h");
1902 if (c == -1) {
1903 break;
1904 }
1905 switch(c) {
Jes Sorensenef873942010-12-06 15:25:40 +01001906 case '?':
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001907 case 'h':
1908 help();
1909 break;
1910 case 'f':
1911 fmt = optarg;
1912 break;
1913 }
1914 }
Kevin Wolfe80fec72011-04-29 10:58:12 +02001915 if (optind >= argc) {
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001916 help();
1917 }
1918 filename = argv[optind++];
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001919
1920 /* Choose grow, shrink, or absolute resize mode */
1921 switch (size[0]) {
1922 case '+':
1923 relative = 1;
1924 size++;
1925 break;
1926 case '-':
1927 relative = -1;
1928 size++;
1929 break;
1930 default:
1931 relative = 0;
1932 break;
1933 }
1934
1935 /* Parse size */
Dong Xu Wang20caf0f2012-08-06 10:18:42 +08001936 param = qemu_opts_create(&resize_options, NULL, 0, NULL);
1937 if (qemu_opt_set(param, BLOCK_OPT_SIZE, size)) {
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001938 /* Error message already printed when size parsing fails */
Jes Sorensen2a819982010-12-06 17:08:31 +01001939 ret = -1;
Dong Xu Wang20caf0f2012-08-06 10:18:42 +08001940 qemu_opts_del(param);
Jes Sorensen2a819982010-12-06 17:08:31 +01001941 goto out;
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001942 }
Dong Xu Wang20caf0f2012-08-06 10:18:42 +08001943 n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
1944 qemu_opts_del(param);
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001945
Daniel P. Berrangef0536bb2012-09-10 12:11:31 +01001946 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR, true);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001947 if (!bs) {
Jes Sorensen2a819982010-12-06 17:08:31 +01001948 ret = -1;
1949 goto out;
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001950 }
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001951
1952 if (relative) {
1953 total_size = bdrv_getlength(bs) + n * relative;
1954 } else {
1955 total_size = n;
1956 }
1957 if (total_size <= 0) {
Jes Sorensen15654a62010-12-16 14:31:53 +01001958 error_report("New image size must be positive");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001959 ret = -1;
1960 goto out;
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001961 }
1962
1963 ret = bdrv_truncate(bs, total_size);
1964 switch (ret) {
1965 case 0:
1966 printf("Image resized.\n");
1967 break;
1968 case -ENOTSUP:
Kevin Wolf259b2172012-03-06 12:44:45 +01001969 error_report("This image does not support resize");
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001970 break;
1971 case -EACCES:
Jes Sorensen15654a62010-12-16 14:31:53 +01001972 error_report("Image is read-only");
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001973 break;
1974 default:
Jes Sorensen15654a62010-12-16 14:31:53 +01001975 error_report("Error resizing image (%d)", -ret);
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001976 break;
1977 }
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001978out:
Jes Sorensen2a819982010-12-06 17:08:31 +01001979 if (bs) {
1980 bdrv_delete(bs);
1981 }
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001982 if (ret) {
1983 return 1;
1984 }
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01001985 return 0;
1986}
1987
Anthony Liguoric227f092009-10-01 16:12:16 -05001988static const img_cmd_t img_cmds[] = {
Stuart Brady153859b2009-06-07 00:42:17 +01001989#define DEF(option, callback, arg_string) \
1990 { option, callback },
1991#include "qemu-img-cmds.h"
1992#undef DEF
1993#undef GEN_DOCS
1994 { NULL, NULL, },
1995};
1996
bellardea2384d2004-08-01 21:59:26 +00001997int main(int argc, char **argv)
1998{
Anthony Liguoric227f092009-10-01 16:12:16 -05001999 const img_cmd_t *cmd;
Stuart Brady153859b2009-06-07 00:42:17 +01002000 const char *cmdname;
bellardea2384d2004-08-01 21:59:26 +00002001
Kevin Wolf53f76e52010-12-16 15:10:32 +01002002 error_set_progname(argv[0]);
2003
Paolo Bonzini2592c592012-11-03 18:10:17 +01002004 qemu_init_main_loop();
bellardea2384d2004-08-01 21:59:26 +00002005 bdrv_init();
2006 if (argc < 2)
2007 help();
Stuart Brady153859b2009-06-07 00:42:17 +01002008 cmdname = argv[1];
aurel328f9b1572009-02-09 18:14:31 +00002009 argc--; argv++;
Stuart Brady153859b2009-06-07 00:42:17 +01002010
2011 /* find the command */
2012 for(cmd = img_cmds; cmd->name != NULL; cmd++) {
2013 if (!strcmp(cmdname, cmd->name)) {
2014 return cmd->handler(argc, argv);
2015 }
bellardea2384d2004-08-01 21:59:26 +00002016 }
Stuart Brady153859b2009-06-07 00:42:17 +01002017
2018 /* not found */
2019 help();
bellardea2384d2004-08-01 21:59:26 +00002020 return 0;
2021}