blob: 9831db75ef1b5ea3d8a7f554c60cb2c879f898f4 [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"
Markus Armbrustercc7a8ea2015-03-17 17:22:46 +010026#include "qapi/qmp/qerror.h"
Paolo Bonzini7b1b5d12012-12-17 18:19:43 +010027#include "qapi/qmp/qjson.h"
pbrookfaf07962007-11-11 02:51:17 +000028#include "qemu-common.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010029#include "qemu/option.h"
30#include "qemu/error-report.h"
31#include "qemu/osdep.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010032#include "sysemu/sysemu.h"
Markus Armbruster26f54e92014-10-07 13:59:04 +020033#include "sysemu/block-backend.h"
Paolo Bonzini737e1502012-12-17 18:19:44 +010034#include "block/block_int.h"
Max Reitzd4a32382014-10-24 15:57:37 +020035#include "block/blockjob.h"
Wenchao Xiaf364ec62013-05-25 11:09:44 +080036#include "block/qapi.h"
Benoît Canetc054b3f2012-09-05 13:09:02 +020037#include <getopt.h>
bellarde8445332006-06-14 15:32:10 +000038
Don Slutz61979a62015-01-09 10:17:35 -050039#define QEMU_IMG_VERSION "qemu-img version " QEMU_VERSION QEMU_PKGVERSION \
Jeff Cody5f6979c2014-04-28 14:37:18 -040040 ", Copyright (c) 2004-2008 Fabrice Bellard\n"
41
Anthony Liguoric227f092009-10-01 16:12:16 -050042typedef struct img_cmd_t {
Stuart Brady153859b2009-06-07 00:42:17 +010043 const char *name;
44 int (*handler)(int argc, char **argv);
Anthony Liguoric227f092009-10-01 16:12:16 -050045} img_cmd_t;
Stuart Brady153859b2009-06-07 00:42:17 +010046
Federico Simoncelli8599ea42013-01-28 06:59:47 -050047enum {
48 OPTION_OUTPUT = 256,
49 OPTION_BACKING_CHAIN = 257,
50};
51
52typedef enum OutputFormat {
53 OFORMAT_JSON,
54 OFORMAT_HUMAN,
55} OutputFormat;
56
aurel32137519c2008-11-30 19:12:49 +000057/* Default to cache=writeback as data integrity is not important for qemu-tcg. */
Stefan Hajnocziadfe0782010-04-13 10:29:35 +010058#define BDRV_O_FLAGS BDRV_O_CACHE_WB
Federico Simoncelli661a0f72011-06-20 12:48:19 -040059#define BDRV_DEFAULT_CACHE "writeback"
aurel32137519c2008-11-30 19:12:49 +000060
Stefan Hajnoczi00c6d402014-08-27 12:08:56 +010061static void format_print(void *opaque, const char *name)
bellardea2384d2004-08-01 21:59:26 +000062{
Stefan Hajnoczi00c6d402014-08-27 12:08:56 +010063 printf(" %s", name);
bellardea2384d2004-08-01 21:59:26 +000064}
65
Fam Zhengac1307a2014-04-22 13:36:11 +080066static void QEMU_NORETURN GCC_FMT_ATTR(1, 2) error_exit(const char *fmt, ...)
67{
68 va_list ap;
69
70 error_printf("qemu-img: ");
71
72 va_start(ap, fmt);
73 error_vprintf(fmt, ap);
74 va_end(ap);
75
76 error_printf("\nTry 'qemu-img --help' for more information\n");
77 exit(EXIT_FAILURE);
78}
79
blueswir1d2c639d2009-01-24 18:19:25 +000080/* Please keep in synch with qemu-img.texi */
Fam Zhengac1307a2014-04-22 13:36:11 +080081static void QEMU_NORETURN help(void)
bellardea2384d2004-08-01 21:59:26 +000082{
Paolo Bonzinie00291c2010-02-04 16:49:56 +010083 const char *help_msg =
Jeff Cody5f6979c2014-04-28 14:37:18 -040084 QEMU_IMG_VERSION
malc3f020d72010-02-08 12:04:56 +030085 "usage: qemu-img command [command options]\n"
86 "QEMU disk image utility\n"
87 "\n"
88 "Command syntax:\n"
Stuart Brady153859b2009-06-07 00:42:17 +010089#define DEF(option, callback, arg_string) \
90 " " arg_string "\n"
91#include "qemu-img-cmds.h"
92#undef DEF
93#undef GEN_DOCS
malc3f020d72010-02-08 12:04:56 +030094 "\n"
95 "Command parameters:\n"
96 " 'filename' is a disk image filename\n"
97 " 'fmt' is the disk image format. It is guessed automatically in most cases\n"
Federico Simoncelli661a0f72011-06-20 12:48:19 -040098 " 'cache' is the cache mode used to write the output disk image, the valid\n"
Liu Yuan80ccf932012-04-20 17:10:56 +080099 " options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n"
100 " 'directsync' and 'unsafe' (default for convert)\n"
Stefan Hajnoczibb87fdf2014-09-02 11:01:02 +0100101 " 'src_cache' is the cache mode used to read input disk images, the valid\n"
102 " options are the same as for the 'cache' option\n"
malc3f020d72010-02-08 12:04:56 +0300103 " 'size' is the disk image size in bytes. Optional suffixes\n"
Kevin Wolf5e009842013-06-05 14:19:27 +0200104 " 'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M),\n"
105 " 'T' (terabyte, 1024G), 'P' (petabyte, 1024T) and 'E' (exabyte, 1024P) are\n"
106 " supported. 'b' is ignored.\n"
malc3f020d72010-02-08 12:04:56 +0300107 " 'output_filename' is the destination disk image filename\n"
108 " 'output_fmt' is the destination format\n"
109 " 'options' is a comma separated list of format specific options in a\n"
110 " name=value format. Use -o ? for an overview of the options supported by the\n"
111 " used format\n"
Wenchao Xiaef806542013-12-04 17:10:57 +0800112 " 'snapshot_param' is param used for internal snapshot, format\n"
113 " is 'snapshot.id=[ID],snapshot.name=[NAME]', or\n"
114 " '[ID_OR_NAME]'\n"
115 " 'snapshot_id_or_name' is deprecated, use 'snapshot_param'\n"
116 " instead\n"
malc3f020d72010-02-08 12:04:56 +0300117 " '-c' indicates that target image must be compressed (qcow format only)\n"
118 " '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
119 " match exactly. The image doesn't need a working backing file before\n"
120 " rebasing in this case (useful for renaming the backing file)\n"
121 " '-h' with or without a command shows this help and lists the supported formats\n"
Jes Sorensen6b837bc2011-03-30 14:16:25 +0200122 " '-p' show progress of command (only certain commands)\n"
Miroslav Rezaninaf382d432013-02-13 09:09:40 +0100123 " '-q' use Quiet mode - do not print any output (except errors)\n"
Peter Lieven11b66992013-10-24 12:07:05 +0200124 " '-S' indicates the consecutive number of bytes (defaults to 4k) that must\n"
125 " contain only zeros for qemu-img to create a sparse image during\n"
126 " conversion. If the number of bytes is 0, the source will not be scanned for\n"
127 " unallocated or zero sectors, and the destination image will always be\n"
128 " fully allocated\n"
Benoît Canetc054b3f2012-09-05 13:09:02 +0200129 " '--output' takes the format in which the output must be done (human or json)\n"
Alexandre Derumierb2e10492013-09-02 19:07:24 +0100130 " '-n' skips the target volume creation (useful if the volume is created\n"
131 " prior to running qemu-img)\n"
malc3f020d72010-02-08 12:04:56 +0300132 "\n"
Kevin Wolf4534ff52012-05-11 16:07:02 +0200133 "Parameters to check subcommand:\n"
134 " '-r' tries to repair any inconsistencies that are found during the check.\n"
135 " '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n"
136 " kinds of errors, with a higher risk of choosing the wrong fix or\n"
Stefan Weil0546b8c2012-08-10 22:03:25 +0200137 " hiding corruption that has already occurred.\n"
Kevin Wolf4534ff52012-05-11 16:07:02 +0200138 "\n"
malc3f020d72010-02-08 12:04:56 +0300139 "Parameters to snapshot subcommand:\n"
140 " 'snapshot' is the name of the snapshot to create, apply or delete\n"
141 " '-a' applies a snapshot (revert disk to saved state)\n"
142 " '-c' creates a snapshot\n"
143 " '-d' deletes a snapshot\n"
Miroslav Rezaninad14ed182013-02-13 09:09:41 +0100144 " '-l' lists all snapshots in the given image\n"
145 "\n"
146 "Parameters to compare subcommand:\n"
147 " '-f' first image format\n"
148 " '-F' second image format\n"
149 " '-s' run in Strict mode - fail on different image size or sector allocation\n";
Paolo Bonzinie00291c2010-02-04 16:49:56 +0100150
151 printf("%s\nSupported formats:", help_msg);
Stefan Hajnoczi00c6d402014-08-27 12:08:56 +0100152 bdrv_iterate_format(format_print, NULL);
bellardea2384d2004-08-01 21:59:26 +0000153 printf("\n");
Fam Zhengac1307a2014-04-22 13:36:11 +0800154 exit(EXIT_SUCCESS);
bellardea2384d2004-08-01 21:59:26 +0000155}
156
Stefan Weil7c30f652013-06-16 17:01:05 +0200157static int GCC_FMT_ATTR(2, 3) qprintf(bool quiet, const char *fmt, ...)
Miroslav Rezaninaf382d432013-02-13 09:09:40 +0100158{
159 int ret = 0;
160 if (!quiet) {
161 va_list args;
162 va_start(args, fmt);
163 ret = vprintf(fmt, args);
164 va_end(args);
165 }
166 return ret;
167}
168
bellardea2384d2004-08-01 21:59:26 +0000169
Jes Sorensen4ac8aac2010-12-06 15:25:38 +0100170static int print_block_option_help(const char *filename, const char *fmt)
171{
172 BlockDriver *drv, *proto_drv;
Chunyan Liu83d05212014-06-05 17:20:51 +0800173 QemuOptsList *create_opts = NULL;
Max Reitzb65a5e12015-02-05 13:58:12 -0500174 Error *local_err = NULL;
Jes Sorensen4ac8aac2010-12-06 15:25:38 +0100175
176 /* Find driver and parse its options */
177 drv = bdrv_find_format(fmt);
178 if (!drv) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100179 error_report("Unknown file format '%s'", fmt);
Jes Sorensen4ac8aac2010-12-06 15:25:38 +0100180 return 1;
181 }
182
Chunyan Liuc282e1f2014-06-05 17:21:11 +0800183 create_opts = qemu_opts_append(create_opts, drv->create_opts);
Kevin Wolfa283cb62014-02-21 16:24:07 +0100184 if (filename) {
Max Reitzb65a5e12015-02-05 13:58:12 -0500185 proto_drv = bdrv_find_protocol(filename, true, &local_err);
Kevin Wolfa283cb62014-02-21 16:24:07 +0100186 if (!proto_drv) {
Markus Armbruster2867ce42015-03-12 16:08:02 +0100187 error_report_err(local_err);
Chunyan Liu83d05212014-06-05 17:20:51 +0800188 qemu_opts_free(create_opts);
Kevin Wolfa283cb62014-02-21 16:24:07 +0100189 return 1;
190 }
Chunyan Liuc282e1f2014-06-05 17:21:11 +0800191 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
Kevin Wolfa283cb62014-02-21 16:24:07 +0100192 }
193
Chunyan Liu83d05212014-06-05 17:20:51 +0800194 qemu_opts_print_help(create_opts);
195 qemu_opts_free(create_opts);
Jes Sorensen4ac8aac2010-12-06 15:25:38 +0100196 return 0;
197}
198
Markus Armbruster7e7d56d2014-10-07 13:59:05 +0200199static BlockBackend *img_open(const char *id, const char *filename,
200 const char *fmt, int flags,
201 bool require_io, bool quiet)
bellard75c23802004-08-27 21:28:58 +0000202{
Markus Armbruster7e7d56d2014-10-07 13:59:05 +0200203 BlockBackend *blk;
bellard75c23802004-08-27 21:28:58 +0000204 BlockDriverState *bs;
bellard75c23802004-08-27 21:28:58 +0000205 char password[256];
Max Reitz34b5d2c2013-09-05 14:45:29 +0200206 Error *local_err = NULL;
Max Reitz5bd31322015-02-05 13:58:16 -0500207 QDict *options = NULL;
Kevin Wolfad717132010-12-16 15:37:41 +0100208
bellard75c23802004-08-27 21:28:58 +0000209 if (fmt) {
Max Reitz5bd31322015-02-05 13:58:16 -0500210 options = qdict_new();
211 qdict_put(options, "driver", qstring_from_str(fmt));
bellard75c23802004-08-27 21:28:58 +0000212 }
Kevin Wolfb9eaf9e2011-02-09 11:25:53 +0100213
Max Reitz5bd31322015-02-05 13:58:16 -0500214 blk = blk_new_open(id, filename, NULL, options, flags, &local_err);
215 if (!blk) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200216 error_report("Could not open '%s': %s", filename,
217 error_get_pretty(local_err));
218 error_free(local_err);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900219 goto fail;
bellard75c23802004-08-27 21:28:58 +0000220 }
Kevin Wolfb9eaf9e2011-02-09 11:25:53 +0100221
Max Reitz5bd31322015-02-05 13:58:16 -0500222 bs = blk_bs(blk);
Daniel P. Berrangef0536bb2012-09-10 12:11:31 +0100223 if (bdrv_is_encrypted(bs) && require_io) {
Miroslav Rezaninaf382d432013-02-13 09:09:40 +0100224 qprintf(quiet, "Disk image '%s' is encrypted.\n", filename);
Daniel P. Berranged57e4e42015-05-12 17:09:19 +0100225 if (qemu_read_password(password, sizeof(password)) < 0) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100226 error_report("No password given");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900227 goto fail;
228 }
229 if (bdrv_set_key(bs, password) < 0) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100230 error_report("invalid password");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900231 goto fail;
232 }
bellard75c23802004-08-27 21:28:58 +0000233 }
Markus Armbruster7e7d56d2014-10-07 13:59:05 +0200234 return blk;
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900235fail:
Markus Armbruster7e7d56d2014-10-07 13:59:05 +0200236 blk_unref(blk);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900237 return NULL;
bellard75c23802004-08-27 21:28:58 +0000238}
239
Chunyan Liu83d05212014-06-05 17:20:51 +0800240static int add_old_style_options(const char *fmt, QemuOpts *opts,
Jes Sorenseneec77d92010-12-07 17:44:34 +0100241 const char *base_filename,
242 const char *base_fmt)
Kevin Wolfefa84d42009-05-18 16:42:12 +0200243{
Markus Armbruster6750e792015-02-12 17:43:08 +0100244 Error *err = NULL;
245
Kevin Wolfefa84d42009-05-18 16:42:12 +0200246 if (base_filename) {
Markus Armbrusterf43e47d2015-02-12 17:52:20 +0100247 qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &err);
Markus Armbruster6750e792015-02-12 17:43:08 +0100248 if (err) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100249 error_report("Backing file not supported for file format '%s'",
250 fmt);
Markus Armbruster6750e792015-02-12 17:43:08 +0100251 error_free(err);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900252 return -1;
Kevin Wolfefa84d42009-05-18 16:42:12 +0200253 }
254 }
255 if (base_fmt) {
Markus Armbrusterf43e47d2015-02-12 17:52:20 +0100256 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &err);
Markus Armbruster6750e792015-02-12 17:43:08 +0100257 if (err) {
Jes Sorensen15654a62010-12-16 14:31:53 +0100258 error_report("Backing file format not supported for file "
259 "format '%s'", fmt);
Markus Armbruster6750e792015-02-12 17:43:08 +0100260 error_free(err);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900261 return -1;
Kevin Wolfefa84d42009-05-18 16:42:12 +0200262 }
263 }
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900264 return 0;
Kevin Wolfefa84d42009-05-18 16:42:12 +0200265}
266
bellardea2384d2004-08-01 21:59:26 +0000267static int img_create(int argc, char **argv)
268{
Luiz Capitulinoa9300912012-11-30 10:52:06 -0200269 int c;
Jes Sorensen1da7cfb2010-12-09 14:17:25 +0100270 uint64_t img_size = -1;
bellardea2384d2004-08-01 21:59:26 +0000271 const char *fmt = "raw";
aliguori9230eaf2009-03-28 17:55:19 +0000272 const char *base_fmt = NULL;
bellardea2384d2004-08-01 21:59:26 +0000273 const char *filename;
274 const char *base_filename = NULL;
Kevin Wolf9ea2ea72009-05-18 16:42:11 +0200275 char *options = NULL;
Luiz Capitulino9b375252012-11-30 10:52:05 -0200276 Error *local_err = NULL;
Miroslav Rezaninaf382d432013-02-13 09:09:40 +0100277 bool quiet = false;
ths3b46e622007-09-17 08:09:54 +0000278
bellardea2384d2004-08-01 21:59:26 +0000279 for(;;) {
Miroslav Rezaninaf382d432013-02-13 09:09:40 +0100280 c = getopt(argc, argv, "F:b:f:he6o:q");
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100281 if (c == -1) {
bellardea2384d2004-08-01 21:59:26 +0000282 break;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100283 }
bellardea2384d2004-08-01 21:59:26 +0000284 switch(c) {
Jes Sorensenef873942010-12-06 15:25:40 +0100285 case '?':
bellardea2384d2004-08-01 21:59:26 +0000286 case 'h':
287 help();
288 break;
aliguori9230eaf2009-03-28 17:55:19 +0000289 case 'F':
290 base_fmt = optarg;
291 break;
bellardea2384d2004-08-01 21:59:26 +0000292 case 'b':
293 base_filename = optarg;
294 break;
295 case 'f':
296 fmt = optarg;
297 break;
298 case 'e':
Markus Armbruster9d42e152011-06-22 14:03:55 +0200299 error_report("option -e is deprecated, please use \'-o "
Jes Sorenseneec77d92010-12-07 17:44:34 +0100300 "encryption\' instead!");
Kevin Wolf77386bf2014-02-21 16:24:04 +0100301 goto fail;
thsd8871c52007-10-24 16:11:42 +0000302 case '6':
Markus Armbruster9d42e152011-06-22 14:03:55 +0200303 error_report("option -6 is deprecated, please use \'-o "
Jes Sorenseneec77d92010-12-07 17:44:34 +0100304 "compat6\' instead!");
Kevin Wolf77386bf2014-02-21 16:24:04 +0100305 goto fail;
Kevin Wolf9ea2ea72009-05-18 16:42:11 +0200306 case 'o':
Kevin Wolf77386bf2014-02-21 16:24:04 +0100307 if (!is_valid_option_list(optarg)) {
308 error_report("Invalid option list: %s", optarg);
309 goto fail;
310 }
311 if (!options) {
312 options = g_strdup(optarg);
313 } else {
314 char *old_options = options;
315 options = g_strdup_printf("%s,%s", options, optarg);
316 g_free(old_options);
317 }
Kevin Wolf9ea2ea72009-05-18 16:42:11 +0200318 break;
Miroslav Rezaninaf382d432013-02-13 09:09:40 +0100319 case 'q':
320 quiet = true;
321 break;
bellardea2384d2004-08-01 21:59:26 +0000322 }
323 }
aliguori9230eaf2009-03-28 17:55:19 +0000324
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900325 /* Get the filename */
Kevin Wolfa283cb62014-02-21 16:24:07 +0100326 filename = (optind < argc) ? argv[optind] : NULL;
327 if (options && has_help_option(options)) {
328 g_free(options);
329 return print_block_option_help(filename, fmt);
330 }
331
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100332 if (optind >= argc) {
Fam Zhengac1307a2014-04-22 13:36:11 +0800333 error_exit("Expecting image file name");
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100334 }
Kevin Wolfa283cb62014-02-21 16:24:07 +0100335 optind++;
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900336
Jes Sorensen1da7cfb2010-12-09 14:17:25 +0100337 /* Get image size, if specified */
338 if (optind < argc) {
Jes Sorensen70b4f4b2011-01-05 11:41:02 +0100339 int64_t sval;
Markus Armbrustere36b3692011-11-22 09:46:05 +0100340 char *end;
Marc-André Lureau4677bb42015-09-16 18:02:56 +0200341 sval = qemu_strtosz_suffix(argv[optind++], &end,
342 QEMU_STRTOSZ_DEFSUFFIX_B);
Markus Armbrustere36b3692011-11-22 09:46:05 +0100343 if (sval < 0 || *end) {
liguang79443392012-12-17 09:49:23 +0800344 if (sval == -ERANGE) {
345 error_report("Image size must be less than 8 EiB!");
346 } else {
347 error_report("Invalid image size specified! You may use k, M, "
Kevin Wolf5e009842013-06-05 14:19:27 +0200348 "G, T, P or E suffixes for ");
349 error_report("kilobytes, megabytes, gigabytes, terabytes, "
350 "petabytes and exabytes.");
liguang79443392012-12-17 09:49:23 +0800351 }
Kevin Wolf77386bf2014-02-21 16:24:04 +0100352 goto fail;
Jes Sorensen1da7cfb2010-12-09 14:17:25 +0100353 }
354 img_size = (uint64_t)sval;
355 }
Kevin Wolffc11eb22013-08-05 10:53:04 +0200356 if (optind != argc) {
Fam Zhengac1307a2014-04-22 13:36:11 +0800357 error_exit("Unexpected argument: %s", argv[optind]);
Kevin Wolffc11eb22013-08-05 10:53:04 +0200358 }
Jes Sorensen1da7cfb2010-12-09 14:17:25 +0100359
Luiz Capitulino9b375252012-11-30 10:52:05 -0200360 bdrv_img_create(filename, fmt, base_filename, base_fmt,
Miroslav Rezaninaf382d432013-02-13 09:09:40 +0100361 options, img_size, BDRV_O_FLAGS, &local_err, quiet);
Markus Armbruster84d18f02014-01-30 15:07:28 +0100362 if (local_err) {
Max Reitzb70d8c22013-09-06 16:51:03 +0200363 error_report("%s: %s", filename, error_get_pretty(local_err));
Luiz Capitulino9b375252012-11-30 10:52:05 -0200364 error_free(local_err);
Kevin Wolf77386bf2014-02-21 16:24:04 +0100365 goto fail;
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900366 }
Luiz Capitulinoa9300912012-11-30 10:52:06 -0200367
Kevin Wolf77386bf2014-02-21 16:24:04 +0100368 g_free(options);
bellardea2384d2004-08-01 21:59:26 +0000369 return 0;
Kevin Wolf77386bf2014-02-21 16:24:04 +0100370
371fail:
372 g_free(options);
373 return 1;
bellardea2384d2004-08-01 21:59:26 +0000374}
375
Miroslav Rezaninaf382d432013-02-13 09:09:40 +0100376static void dump_json_image_check(ImageCheck *check, bool quiet)
Federico Simoncelli8599ea42013-01-28 06:59:47 -0500377{
Markus Armbruster4399c432014-04-25 16:50:32 +0200378 Error *local_err = NULL;
Federico Simoncelli8599ea42013-01-28 06:59:47 -0500379 QString *str;
380 QmpOutputVisitor *ov = qmp_output_visitor_new();
381 QObject *obj;
382 visit_type_ImageCheck(qmp_output_get_visitor(ov),
Markus Armbruster4399c432014-04-25 16:50:32 +0200383 &check, NULL, &local_err);
Federico Simoncelli8599ea42013-01-28 06:59:47 -0500384 obj = qmp_output_get_qobject(ov);
385 str = qobject_to_json_pretty(obj);
386 assert(str != NULL);
Miroslav Rezaninaf382d432013-02-13 09:09:40 +0100387 qprintf(quiet, "%s\n", qstring_get_str(str));
Federico Simoncelli8599ea42013-01-28 06:59:47 -0500388 qobject_decref(obj);
389 qmp_output_visitor_cleanup(ov);
390 QDECREF(str);
391}
392
Miroslav Rezaninaf382d432013-02-13 09:09:40 +0100393static void dump_human_image_check(ImageCheck *check, bool quiet)
Federico Simoncelli8599ea42013-01-28 06:59:47 -0500394{
395 if (!(check->corruptions || check->leaks || check->check_errors)) {
Miroslav Rezaninaf382d432013-02-13 09:09:40 +0100396 qprintf(quiet, "No errors were found on the image.\n");
Federico Simoncelli8599ea42013-01-28 06:59:47 -0500397 } else {
398 if (check->corruptions) {
Miroslav Rezaninaf382d432013-02-13 09:09:40 +0100399 qprintf(quiet, "\n%" PRId64 " errors were found on the image.\n"
400 "Data may be corrupted, or further writes to the image "
401 "may corrupt it.\n",
402 check->corruptions);
Federico Simoncelli8599ea42013-01-28 06:59:47 -0500403 }
404
405 if (check->leaks) {
Miroslav Rezaninaf382d432013-02-13 09:09:40 +0100406 qprintf(quiet,
407 "\n%" PRId64 " leaked clusters were found on the image.\n"
408 "This means waste of disk space, but no harm to data.\n",
409 check->leaks);
Federico Simoncelli8599ea42013-01-28 06:59:47 -0500410 }
411
412 if (check->check_errors) {
Miroslav Rezaninaf382d432013-02-13 09:09:40 +0100413 qprintf(quiet,
414 "\n%" PRId64
415 " internal errors have occurred during the check.\n",
416 check->check_errors);
Federico Simoncelli8599ea42013-01-28 06:59:47 -0500417 }
418 }
419
420 if (check->total_clusters != 0 && check->allocated_clusters != 0) {
Miroslav Rezaninaf382d432013-02-13 09:09:40 +0100421 qprintf(quiet, "%" PRId64 "/%" PRId64 " = %0.2f%% allocated, "
422 "%0.2f%% fragmented, %0.2f%% compressed clusters\n",
423 check->allocated_clusters, check->total_clusters,
424 check->allocated_clusters * 100.0 / check->total_clusters,
425 check->fragmented_clusters * 100.0 / check->allocated_clusters,
426 check->compressed_clusters * 100.0 /
427 check->allocated_clusters);
Federico Simoncelli8599ea42013-01-28 06:59:47 -0500428 }
429
430 if (check->image_end_offset) {
Miroslav Rezaninaf382d432013-02-13 09:09:40 +0100431 qprintf(quiet,
432 "Image end offset: %" PRId64 "\n", check->image_end_offset);
Federico Simoncelli8599ea42013-01-28 06:59:47 -0500433 }
434}
435
436static int collect_image_check(BlockDriverState *bs,
437 ImageCheck *check,
438 const char *filename,
439 const char *fmt,
440 int fix)
441{
442 int ret;
443 BdrvCheckResult result;
444
445 ret = bdrv_check(bs, &result, fix);
446 if (ret < 0) {
447 return ret;
448 }
449
450 check->filename = g_strdup(filename);
451 check->format = g_strdup(bdrv_get_format_name(bs));
452 check->check_errors = result.check_errors;
453 check->corruptions = result.corruptions;
454 check->has_corruptions = result.corruptions != 0;
455 check->leaks = result.leaks;
456 check->has_leaks = result.leaks != 0;
457 check->corruptions_fixed = result.corruptions_fixed;
458 check->has_corruptions_fixed = result.corruptions != 0;
459 check->leaks_fixed = result.leaks_fixed;
460 check->has_leaks_fixed = result.leaks != 0;
461 check->image_end_offset = result.image_end_offset;
462 check->has_image_end_offset = result.image_end_offset != 0;
463 check->total_clusters = result.bfi.total_clusters;
464 check->has_total_clusters = result.bfi.total_clusters != 0;
465 check->allocated_clusters = result.bfi.allocated_clusters;
466 check->has_allocated_clusters = result.bfi.allocated_clusters != 0;
467 check->fragmented_clusters = result.bfi.fragmented_clusters;
468 check->has_fragmented_clusters = result.bfi.fragmented_clusters != 0;
Stefan Hajnoczie6439d72013-02-07 17:15:04 +0100469 check->compressed_clusters = result.bfi.compressed_clusters;
470 check->has_compressed_clusters = result.bfi.compressed_clusters != 0;
Federico Simoncelli8599ea42013-01-28 06:59:47 -0500471
472 return 0;
473}
474
Kevin Wolfe076f332010-06-29 11:43:13 +0200475/*
476 * Checks an image for consistency. Exit codes:
477 *
Max Reitzd6635c42014-06-02 22:15:21 +0200478 * 0 - Check completed, image is good
479 * 1 - Check not completed because of internal errors
480 * 2 - Check completed, image is corrupted
481 * 3 - Check completed, image has leaked clusters, but is good otherwise
482 * 63 - Checks are not supported by the image format
Kevin Wolfe076f332010-06-29 11:43:13 +0200483 */
aliguori15859692009-04-21 23:11:53 +0000484static int img_check(int argc, char **argv)
485{
486 int c, ret;
Federico Simoncelli8599ea42013-01-28 06:59:47 -0500487 OutputFormat output_format = OFORMAT_HUMAN;
Max Reitz40055952014-07-22 22:58:42 +0200488 const char *filename, *fmt, *output, *cache;
Markus Armbruster26f54e92014-10-07 13:59:04 +0200489 BlockBackend *blk;
aliguori15859692009-04-21 23:11:53 +0000490 BlockDriverState *bs;
Kevin Wolf4534ff52012-05-11 16:07:02 +0200491 int fix = 0;
Stefan Hajnoczi058f8f12012-08-09 13:05:56 +0100492 int flags = BDRV_O_FLAGS | BDRV_O_CHECK;
Markus Armbruster7e7d56d2014-10-07 13:59:05 +0200493 ImageCheck *check;
Miroslav Rezaninaf382d432013-02-13 09:09:40 +0100494 bool quiet = false;
aliguori15859692009-04-21 23:11:53 +0000495
496 fmt = NULL;
Federico Simoncelli8599ea42013-01-28 06:59:47 -0500497 output = NULL;
Max Reitz40055952014-07-22 22:58:42 +0200498 cache = BDRV_DEFAULT_CACHE;
aliguori15859692009-04-21 23:11:53 +0000499 for(;;) {
Federico Simoncelli8599ea42013-01-28 06:59:47 -0500500 int option_index = 0;
501 static const struct option long_options[] = {
502 {"help", no_argument, 0, 'h'},
503 {"format", required_argument, 0, 'f'},
Prasad Joshi4fd6a982014-03-25 00:08:54 +0530504 {"repair", required_argument, 0, 'r'},
Federico Simoncelli8599ea42013-01-28 06:59:47 -0500505 {"output", required_argument, 0, OPTION_OUTPUT},
506 {0, 0, 0, 0}
507 };
Max Reitz40055952014-07-22 22:58:42 +0200508 c = getopt_long(argc, argv, "hf:r:T:q",
Federico Simoncelli8599ea42013-01-28 06:59:47 -0500509 long_options, &option_index);
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100510 if (c == -1) {
aliguori15859692009-04-21 23:11:53 +0000511 break;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100512 }
aliguori15859692009-04-21 23:11:53 +0000513 switch(c) {
Jes Sorensenef873942010-12-06 15:25:40 +0100514 case '?':
aliguori15859692009-04-21 23:11:53 +0000515 case 'h':
516 help();
517 break;
518 case 'f':
519 fmt = optarg;
520 break;
Kevin Wolf4534ff52012-05-11 16:07:02 +0200521 case 'r':
522 flags |= BDRV_O_RDWR;
523
524 if (!strcmp(optarg, "leaks")) {
525 fix = BDRV_FIX_LEAKS;
526 } else if (!strcmp(optarg, "all")) {
527 fix = BDRV_FIX_LEAKS | BDRV_FIX_ERRORS;
528 } else {
Fam Zhengac1307a2014-04-22 13:36:11 +0800529 error_exit("Unknown option value for -r "
530 "(expecting 'leaks' or 'all'): %s", optarg);
Kevin Wolf4534ff52012-05-11 16:07:02 +0200531 }
532 break;
Federico Simoncelli8599ea42013-01-28 06:59:47 -0500533 case OPTION_OUTPUT:
534 output = optarg;
535 break;
Max Reitz40055952014-07-22 22:58:42 +0200536 case 'T':
537 cache = optarg;
538 break;
Miroslav Rezaninaf382d432013-02-13 09:09:40 +0100539 case 'q':
540 quiet = true;
541 break;
aliguori15859692009-04-21 23:11:53 +0000542 }
543 }
Kevin Wolffc11eb22013-08-05 10:53:04 +0200544 if (optind != argc - 1) {
Fam Zhengac1307a2014-04-22 13:36:11 +0800545 error_exit("Expecting one image file name");
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100546 }
aliguori15859692009-04-21 23:11:53 +0000547 filename = argv[optind++];
548
Federico Simoncelli8599ea42013-01-28 06:59:47 -0500549 if (output && !strcmp(output, "json")) {
550 output_format = OFORMAT_JSON;
551 } else if (output && !strcmp(output, "human")) {
552 output_format = OFORMAT_HUMAN;
553 } else if (output) {
554 error_report("--output must be used with human or json as argument.");
555 return 1;
556 }
557
Max Reitz40055952014-07-22 22:58:42 +0200558 ret = bdrv_parse_cache_flags(cache, &flags);
559 if (ret < 0) {
560 error_report("Invalid source cache option: %s", cache);
561 return 1;
562 }
563
Markus Armbruster7e7d56d2014-10-07 13:59:05 +0200564 blk = img_open("image", filename, fmt, flags, true, quiet);
565 if (!blk) {
566 return 1;
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900567 }
Markus Armbruster7e7d56d2014-10-07 13:59:05 +0200568 bs = blk_bs(blk);
Federico Simoncelli8599ea42013-01-28 06:59:47 -0500569
570 check = g_new0(ImageCheck, 1);
571 ret = collect_image_check(bs, check, filename, fmt, fix);
Kevin Wolfe076f332010-06-29 11:43:13 +0200572
573 if (ret == -ENOTSUP) {
Max Reitz55d492d2014-05-31 21:33:30 +0200574 error_report("This image format does not support checks");
Peter Lievenfefddf92013-10-24 08:53:34 +0200575 ret = 63;
Federico Simoncelli8599ea42013-01-28 06:59:47 -0500576 goto fail;
Kevin Wolfe076f332010-06-29 11:43:13 +0200577 }
578
Federico Simoncelli8599ea42013-01-28 06:59:47 -0500579 if (check->corruptions_fixed || check->leaks_fixed) {
580 int corruptions_fixed, leaks_fixed;
581
582 leaks_fixed = check->leaks_fixed;
583 corruptions_fixed = check->corruptions_fixed;
584
585 if (output_format == OFORMAT_HUMAN) {
Miroslav Rezaninaf382d432013-02-13 09:09:40 +0100586 qprintf(quiet,
587 "The following inconsistencies were found and repaired:\n\n"
588 " %" PRId64 " leaked clusters\n"
589 " %" PRId64 " corruptions\n\n"
590 "Double checking the fixed image now...\n",
591 check->leaks_fixed,
592 check->corruptions_fixed);
Federico Simoncelli8599ea42013-01-28 06:59:47 -0500593 }
594
595 ret = collect_image_check(bs, check, filename, fmt, 0);
596
597 check->leaks_fixed = leaks_fixed;
598 check->corruptions_fixed = corruptions_fixed;
Kevin Wolfccf34712012-05-11 18:16:54 +0200599 }
600
Max Reitz832390a2014-10-23 15:29:12 +0200601 if (!ret) {
602 switch (output_format) {
603 case OFORMAT_HUMAN:
604 dump_human_image_check(check, quiet);
605 break;
606 case OFORMAT_JSON:
607 dump_json_image_check(check, quiet);
608 break;
609 }
Federico Simoncelli8599ea42013-01-28 06:59:47 -0500610 }
611
612 if (ret || check->check_errors) {
Max Reitz832390a2014-10-23 15:29:12 +0200613 if (ret) {
614 error_report("Check failed: %s", strerror(-ret));
615 } else {
616 error_report("Check failed");
617 }
Federico Simoncelli8599ea42013-01-28 06:59:47 -0500618 ret = 1;
619 goto fail;
620 }
621
622 if (check->corruptions) {
623 ret = 2;
624 } else if (check->leaks) {
625 ret = 3;
Kevin Wolfe076f332010-06-29 11:43:13 +0200626 } else {
Federico Simoncelli8599ea42013-01-28 06:59:47 -0500627 ret = 0;
aliguori15859692009-04-21 23:11:53 +0000628 }
629
Federico Simoncelli8599ea42013-01-28 06:59:47 -0500630fail:
631 qapi_free_ImageCheck(check);
Markus Armbruster26f54e92014-10-07 13:59:04 +0200632 blk_unref(blk);
Federico Simoncelli8599ea42013-01-28 06:59:47 -0500633 return ret;
aliguori15859692009-04-21 23:11:53 +0000634}
635
Max Reitzd4a32382014-10-24 15:57:37 +0200636typedef struct CommonBlockJobCBInfo {
637 BlockDriverState *bs;
638 Error **errp;
639} CommonBlockJobCBInfo;
640
641static void common_block_job_cb(void *opaque, int ret)
642{
643 CommonBlockJobCBInfo *cbi = opaque;
644
645 if (ret < 0) {
646 error_setg_errno(cbi->errp, -ret, "Block job failed");
647 }
648
649 /* Drop this block job's reference */
650 bdrv_unref(cbi->bs);
651}
652
653static void run_block_job(BlockJob *job, Error **errp)
654{
655 AioContext *aio_context = bdrv_get_aio_context(job->bs);
656
657 do {
658 aio_poll(aio_context, true);
John Snow62547b82015-11-02 18:28:20 -0500659 qemu_progress_print(job->len ?
660 ((float)job->offset / job->len * 100.f) : 0.0f, 0);
Max Reitzd4a32382014-10-24 15:57:37 +0200661 } while (!job->ready);
662
663 block_job_complete_sync(job, errp);
Max Reitz687fa1d2014-10-24 15:57:39 +0200664
665 /* A block job may finish instantaneously without publishing any progress,
666 * so just signal completion here */
667 qemu_progress_print(100.f, 0);
Max Reitzd4a32382014-10-24 15:57:37 +0200668}
669
bellardea2384d2004-08-01 21:59:26 +0000670static int img_commit(int argc, char **argv)
671{
Federico Simoncelli661a0f72011-06-20 12:48:19 -0400672 int c, ret, flags;
Max Reitz1b22bff2014-10-24 15:57:40 +0200673 const char *filename, *fmt, *cache, *base;
Markus Armbruster26f54e92014-10-07 13:59:04 +0200674 BlockBackend *blk;
Max Reitzd4a32382014-10-24 15:57:37 +0200675 BlockDriverState *bs, *base_bs;
Max Reitz687fa1d2014-10-24 15:57:39 +0200676 bool progress = false, quiet = false, drop = false;
Max Reitzd4a32382014-10-24 15:57:37 +0200677 Error *local_err = NULL;
678 CommonBlockJobCBInfo cbi;
bellardea2384d2004-08-01 21:59:26 +0000679
680 fmt = NULL;
Federico Simoncelli661a0f72011-06-20 12:48:19 -0400681 cache = BDRV_DEFAULT_CACHE;
Max Reitz1b22bff2014-10-24 15:57:40 +0200682 base = NULL;
bellardea2384d2004-08-01 21:59:26 +0000683 for(;;) {
Max Reitz1b22bff2014-10-24 15:57:40 +0200684 c = getopt(argc, argv, "f:ht:b:dpq");
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100685 if (c == -1) {
bellardea2384d2004-08-01 21:59:26 +0000686 break;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100687 }
bellardea2384d2004-08-01 21:59:26 +0000688 switch(c) {
Jes Sorensenef873942010-12-06 15:25:40 +0100689 case '?':
bellardea2384d2004-08-01 21:59:26 +0000690 case 'h':
691 help();
692 break;
693 case 'f':
694 fmt = optarg;
695 break;
Federico Simoncelli661a0f72011-06-20 12:48:19 -0400696 case 't':
697 cache = optarg;
698 break;
Max Reitz1b22bff2014-10-24 15:57:40 +0200699 case 'b':
700 base = optarg;
701 /* -b implies -d */
702 drop = true;
703 break;
Max Reitz9a86fe42014-10-24 15:57:38 +0200704 case 'd':
705 drop = true;
706 break;
Max Reitz687fa1d2014-10-24 15:57:39 +0200707 case 'p':
708 progress = true;
709 break;
Miroslav Rezaninaf382d432013-02-13 09:09:40 +0100710 case 'q':
711 quiet = true;
712 break;
bellardea2384d2004-08-01 21:59:26 +0000713 }
714 }
Max Reitz687fa1d2014-10-24 15:57:39 +0200715
716 /* Progress is not shown in Quiet mode */
717 if (quiet) {
718 progress = false;
719 }
720
Kevin Wolffc11eb22013-08-05 10:53:04 +0200721 if (optind != argc - 1) {
Fam Zhengac1307a2014-04-22 13:36:11 +0800722 error_exit("Expecting one image file name");
Jes Sorensenb8fb60d2010-12-06 15:25:39 +0100723 }
bellardea2384d2004-08-01 21:59:26 +0000724 filename = argv[optind++];
725
Max Reitz9a86fe42014-10-24 15:57:38 +0200726 flags = BDRV_O_RDWR | BDRV_O_UNMAP;
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100727 ret = bdrv_parse_cache_flags(cache, &flags);
Federico Simoncelli661a0f72011-06-20 12:48:19 -0400728 if (ret < 0) {
729 error_report("Invalid cache option: %s", cache);
Stefan Hajnoczia3981eb2014-08-26 19:17:54 +0100730 return 1;
Federico Simoncelli661a0f72011-06-20 12:48:19 -0400731 }
732
Markus Armbruster7e7d56d2014-10-07 13:59:05 +0200733 blk = img_open("image", filename, fmt, flags, true, quiet);
734 if (!blk) {
735 return 1;
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900736 }
Markus Armbruster7e7d56d2014-10-07 13:59:05 +0200737 bs = blk_bs(blk);
738
Max Reitz687fa1d2014-10-24 15:57:39 +0200739 qemu_progress_init(progress, 1.f);
740 qemu_progress_print(0.f, 100);
741
Max Reitz1b22bff2014-10-24 15:57:40 +0200742 if (base) {
743 base_bs = bdrv_find_backing_image(bs, base);
744 if (!base_bs) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +0100745 error_setg(&local_err, QERR_BASE_NOT_FOUND, base);
Max Reitz1b22bff2014-10-24 15:57:40 +0200746 goto done;
747 }
748 } else {
749 /* This is different from QMP, which by default uses the deepest file in
750 * the backing chain (i.e., the very base); however, the traditional
751 * behavior of qemu-img commit is using the immediate backing file. */
Kevin Wolf760e0062015-06-17 14:55:21 +0200752 base_bs = backing_bs(bs);
Max Reitz1b22bff2014-10-24 15:57:40 +0200753 if (!base_bs) {
754 error_setg(&local_err, "Image does not have a backing file");
755 goto done;
756 }
bellardea2384d2004-08-01 21:59:26 +0000757 }
758
Max Reitzd4a32382014-10-24 15:57:37 +0200759 cbi = (CommonBlockJobCBInfo){
760 .errp = &local_err,
761 .bs = bs,
762 };
763
764 commit_active_start(bs, base_bs, 0, BLOCKDEV_ON_ERROR_REPORT,
765 common_block_job_cb, &cbi, &local_err);
766 if (local_err) {
767 goto done;
768 }
769
Kevin Wolf3f09bfb2015-09-15 11:58:23 +0200770 /* When the block job completes, the BlockBackend reference will point to
771 * the old backing file. In order to avoid that the top image is already
772 * deleted, so we can still empty it afterwards, increment the reference
773 * counter here preemptively. */
Max Reitz9a86fe42014-10-24 15:57:38 +0200774 if (!drop) {
Kevin Wolf3f09bfb2015-09-15 11:58:23 +0200775 bdrv_ref(bs);
Max Reitz9a86fe42014-10-24 15:57:38 +0200776 }
777
Max Reitzd4a32382014-10-24 15:57:37 +0200778 run_block_job(bs->job, &local_err);
Max Reitz9a86fe42014-10-24 15:57:38 +0200779 if (local_err) {
780 goto unref_backing;
781 }
782
Kevin Wolf3f09bfb2015-09-15 11:58:23 +0200783 if (!drop && bs->drv->bdrv_make_empty) {
784 ret = bs->drv->bdrv_make_empty(bs);
Max Reitz9a86fe42014-10-24 15:57:38 +0200785 if (ret) {
786 error_setg_errno(&local_err, -ret, "Could not empty %s",
787 filename);
788 goto unref_backing;
789 }
790 }
791
792unref_backing:
793 if (!drop) {
Kevin Wolf3f09bfb2015-09-15 11:58:23 +0200794 bdrv_unref(bs);
Max Reitz9a86fe42014-10-24 15:57:38 +0200795 }
Max Reitzd4a32382014-10-24 15:57:37 +0200796
797done:
Max Reitz687fa1d2014-10-24 15:57:39 +0200798 qemu_progress_end();
799
Markus Armbruster26f54e92014-10-07 13:59:04 +0200800 blk_unref(blk);
Max Reitzd4a32382014-10-24 15:57:37 +0200801
802 if (local_err) {
Markus Armbruster6936f292015-02-10 15:14:02 +0100803 error_report_err(local_err);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +0900804 return 1;
805 }
Max Reitzd4a32382014-10-24 15:57:37 +0200806
807 qprintf(quiet, "Image committed.\n");
bellardea2384d2004-08-01 21:59:26 +0000808 return 0;
809}
810
Dmitry Konishchevf6a00aa2011-05-18 15:03:59 +0400811/*
thsf58c7b32008-06-05 21:53:49 +0000812 * Returns true iff the first sector pointed to by 'buf' contains at least
813 * a non-NUL byte.
814 *
815 * 'pnum' is set to the number of sectors (including and immediately following
816 * the first one) that are known to be in the same allocated/unallocated state.
817 */
bellardea2384d2004-08-01 21:59:26 +0000818static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
819{
Stefan Hajnoczi1a6d39f2012-02-07 13:27:24 +0000820 bool is_zero;
821 int i;
bellardea2384d2004-08-01 21:59:26 +0000822
823 if (n <= 0) {
824 *pnum = 0;
825 return 0;
826 }
Stefan Hajnoczi1a6d39f2012-02-07 13:27:24 +0000827 is_zero = buffer_is_zero(buf, 512);
bellardea2384d2004-08-01 21:59:26 +0000828 for(i = 1; i < n; i++) {
829 buf += 512;
Stefan Hajnoczi1a6d39f2012-02-07 13:27:24 +0000830 if (is_zero != buffer_is_zero(buf, 512)) {
bellardea2384d2004-08-01 21:59:26 +0000831 break;
Stefan Hajnoczi1a6d39f2012-02-07 13:27:24 +0000832 }
bellardea2384d2004-08-01 21:59:26 +0000833 }
834 *pnum = i;
Stefan Hajnoczi1a6d39f2012-02-07 13:27:24 +0000835 return !is_zero;
bellardea2384d2004-08-01 21:59:26 +0000836}
837
Kevin Wolf3e85c6f2010-01-12 12:55:18 +0100838/*
Kevin Wolfa22f1232011-08-26 15:27:13 +0200839 * Like is_allocated_sectors, but if the buffer starts with a used sector,
840 * up to 'min' consecutive sectors containing zeros are ignored. This avoids
841 * breaking up write requests for only small sparse areas.
842 */
843static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
844 int min)
845{
846 int ret;
847 int num_checked, num_used;
848
849 if (n < min) {
850 min = n;
851 }
852
853 ret = is_allocated_sectors(buf, n, pnum);
854 if (!ret) {
855 return ret;
856 }
857
858 num_used = *pnum;
859 buf += BDRV_SECTOR_SIZE * *pnum;
860 n -= *pnum;
861 num_checked = num_used;
862
863 while (n > 0) {
864 ret = is_allocated_sectors(buf, n, pnum);
865
866 buf += BDRV_SECTOR_SIZE * *pnum;
867 n -= *pnum;
868 num_checked += *pnum;
869 if (ret) {
870 num_used = num_checked;
871 } else if (*pnum >= min) {
872 break;
873 }
874 }
875
876 *pnum = num_used;
877 return 1;
878}
879
880/*
Kevin Wolf3e85c6f2010-01-12 12:55:18 +0100881 * Compares two buffers sector by sector. Returns 0 if the first sector of both
882 * buffers matches, non-zero otherwise.
883 *
884 * pnum is set to the number of sectors (including and immediately following
885 * the first one) that are known to have the same comparison result
886 */
887static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
888 int *pnum)
889{
Radim Krčmář8c1ac472015-02-20 17:06:15 +0100890 bool res;
891 int i;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +0100892
893 if (n <= 0) {
894 *pnum = 0;
895 return 0;
896 }
897
898 res = !!memcmp(buf1, buf2, 512);
899 for(i = 1; i < n; i++) {
900 buf1 += 512;
901 buf2 += 512;
902
903 if (!!memcmp(buf1, buf2, 512) != res) {
904 break;
905 }
906 }
907
908 *pnum = i;
909 return res;
910}
911
Kevin Wolf80ee15a2009-09-15 12:30:43 +0200912#define IO_BUF_SIZE (2 * 1024 * 1024)
bellardea2384d2004-08-01 21:59:26 +0000913
Miroslav Rezaninad14ed182013-02-13 09:09:41 +0100914static int64_t sectors_to_bytes(int64_t sectors)
915{
916 return sectors << BDRV_SECTOR_BITS;
917}
918
919static int64_t sectors_to_process(int64_t total, int64_t from)
920{
921 return MIN(total - from, IO_BUF_SIZE >> BDRV_SECTOR_BITS);
922}
923
924/*
925 * Check if passed sectors are empty (not allocated or contain only 0 bytes)
926 *
927 * Returns 0 in case sectors are filled with 0, 1 if sectors contain non-zero
928 * data and negative value on error.
929 *
Max Reitzf1d3cd72015-02-05 13:58:18 -0500930 * @param blk: BlockBackend for the image
Miroslav Rezaninad14ed182013-02-13 09:09:41 +0100931 * @param sect_num: Number of first sector to check
932 * @param sect_count: Number of sectors to check
933 * @param filename: Name of disk file we are checking (logging purpose)
934 * @param buffer: Allocated buffer for storing read data
935 * @param quiet: Flag for quiet mode
936 */
Max Reitzf1d3cd72015-02-05 13:58:18 -0500937static int check_empty_sectors(BlockBackend *blk, int64_t sect_num,
Miroslav Rezaninad14ed182013-02-13 09:09:41 +0100938 int sect_count, const char *filename,
939 uint8_t *buffer, bool quiet)
940{
941 int pnum, ret = 0;
Max Reitzf1d3cd72015-02-05 13:58:18 -0500942 ret = blk_read(blk, sect_num, buffer, sect_count);
Miroslav Rezaninad14ed182013-02-13 09:09:41 +0100943 if (ret < 0) {
944 error_report("Error while reading offset %" PRId64 " of %s: %s",
945 sectors_to_bytes(sect_num), filename, strerror(-ret));
946 return ret;
947 }
948 ret = is_allocated_sectors(buffer, sect_count, &pnum);
949 if (ret || pnum != sect_count) {
950 qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
951 sectors_to_bytes(ret ? sect_num : sect_num + pnum));
952 return 1;
953 }
954
955 return 0;
956}
957
958/*
959 * Compares two images. Exit codes:
960 *
961 * 0 - Images are identical
962 * 1 - Images differ
963 * >1 - Error occurred
964 */
965static int img_compare(int argc, char **argv)
966{
Max Reitz40055952014-07-22 22:58:42 +0200967 const char *fmt1 = NULL, *fmt2 = NULL, *cache, *filename1, *filename2;
Markus Armbruster26f54e92014-10-07 13:59:04 +0200968 BlockBackend *blk1, *blk2;
Miroslav Rezaninad14ed182013-02-13 09:09:41 +0100969 BlockDriverState *bs1, *bs2;
970 int64_t total_sectors1, total_sectors2;
971 uint8_t *buf1 = NULL, *buf2 = NULL;
972 int pnum1, pnum2;
973 int allocated1, allocated2;
974 int ret = 0; /* return value - 0 Ident, 1 Different, >1 Error */
975 bool progress = false, quiet = false, strict = false;
Max Reitz40055952014-07-22 22:58:42 +0200976 int flags;
Miroslav Rezaninad14ed182013-02-13 09:09:41 +0100977 int64_t total_sectors;
978 int64_t sector_num = 0;
979 int64_t nb_sectors;
980 int c, pnum;
Miroslav Rezaninad14ed182013-02-13 09:09:41 +0100981 uint64_t progress_base;
982
Max Reitz40055952014-07-22 22:58:42 +0200983 cache = BDRV_DEFAULT_CACHE;
Miroslav Rezaninad14ed182013-02-13 09:09:41 +0100984 for (;;) {
Max Reitz40055952014-07-22 22:58:42 +0200985 c = getopt(argc, argv, "hf:F:T:pqs");
Miroslav Rezaninad14ed182013-02-13 09:09:41 +0100986 if (c == -1) {
987 break;
988 }
989 switch (c) {
990 case '?':
991 case 'h':
992 help();
993 break;
994 case 'f':
995 fmt1 = optarg;
996 break;
997 case 'F':
998 fmt2 = optarg;
999 break;
Max Reitz40055952014-07-22 22:58:42 +02001000 case 'T':
1001 cache = optarg;
1002 break;
Miroslav Rezaninad14ed182013-02-13 09:09:41 +01001003 case 'p':
1004 progress = true;
1005 break;
1006 case 'q':
1007 quiet = true;
1008 break;
1009 case 's':
1010 strict = true;
1011 break;
1012 }
1013 }
1014
1015 /* Progress is not shown in Quiet mode */
1016 if (quiet) {
1017 progress = false;
1018 }
1019
1020
Kevin Wolffc11eb22013-08-05 10:53:04 +02001021 if (optind != argc - 2) {
Fam Zhengac1307a2014-04-22 13:36:11 +08001022 error_exit("Expecting two image file names");
Miroslav Rezaninad14ed182013-02-13 09:09:41 +01001023 }
1024 filename1 = argv[optind++];
1025 filename2 = argv[optind++];
1026
Stefan Hajnoczicbda0162014-08-26 19:17:55 +01001027 /* Initialize before goto out */
1028 qemu_progress_init(progress, 2.0);
1029
Max Reitz40055952014-07-22 22:58:42 +02001030 flags = BDRV_O_FLAGS;
1031 ret = bdrv_parse_cache_flags(cache, &flags);
1032 if (ret < 0) {
1033 error_report("Invalid source cache option: %s", cache);
1034 ret = 2;
1035 goto out3;
1036 }
1037
Markus Armbruster7e7d56d2014-10-07 13:59:05 +02001038 blk1 = img_open("image_1", filename1, fmt1, flags, true, quiet);
1039 if (!blk1) {
Miroslav Rezaninad14ed182013-02-13 09:09:41 +01001040 ret = 2;
Markus Armbruster7e7d56d2014-10-07 13:59:05 +02001041 goto out3;
1042 }
1043 bs1 = blk_bs(blk1);
1044
1045 blk2 = img_open("image_2", filename2, fmt2, flags, true, quiet);
1046 if (!blk2) {
Markus Armbruster7e7d56d2014-10-07 13:59:05 +02001047 ret = 2;
Markus Armbruster26f54e92014-10-07 13:59:04 +02001048 goto out2;
Miroslav Rezaninad14ed182013-02-13 09:09:41 +01001049 }
Markus Armbruster7e7d56d2014-10-07 13:59:05 +02001050 bs2 = blk_bs(blk2);
Miroslav Rezaninad14ed182013-02-13 09:09:41 +01001051
Max Reitzf1d3cd72015-02-05 13:58:18 -05001052 buf1 = blk_blockalign(blk1, IO_BUF_SIZE);
1053 buf2 = blk_blockalign(blk2, IO_BUF_SIZE);
1054 total_sectors1 = blk_nb_sectors(blk1);
Markus Armbruster52bf1e72014-06-26 13:23:25 +02001055 if (total_sectors1 < 0) {
1056 error_report("Can't get size of %s: %s",
1057 filename1, strerror(-total_sectors1));
1058 ret = 4;
1059 goto out;
1060 }
Max Reitzf1d3cd72015-02-05 13:58:18 -05001061 total_sectors2 = blk_nb_sectors(blk2);
Markus Armbruster52bf1e72014-06-26 13:23:25 +02001062 if (total_sectors2 < 0) {
1063 error_report("Can't get size of %s: %s",
1064 filename2, strerror(-total_sectors2));
1065 ret = 4;
1066 goto out;
1067 }
Miroslav Rezaninad14ed182013-02-13 09:09:41 +01001068 total_sectors = MIN(total_sectors1, total_sectors2);
1069 progress_base = MAX(total_sectors1, total_sectors2);
1070
1071 qemu_progress_print(0, 100);
1072
1073 if (strict && total_sectors1 != total_sectors2) {
1074 ret = 1;
1075 qprintf(quiet, "Strict mode: Image size mismatch!\n");
1076 goto out;
1077 }
1078
1079 for (;;) {
1080 nb_sectors = sectors_to_process(total_sectors, sector_num);
1081 if (nb_sectors <= 0) {
1082 break;
1083 }
1084 allocated1 = bdrv_is_allocated_above(bs1, NULL, sector_num, nb_sectors,
1085 &pnum1);
1086 if (allocated1 < 0) {
1087 ret = 3;
1088 error_report("Sector allocation test failed for %s", filename1);
1089 goto out;
1090 }
1091
1092 allocated2 = bdrv_is_allocated_above(bs2, NULL, sector_num, nb_sectors,
1093 &pnum2);
1094 if (allocated2 < 0) {
1095 ret = 3;
1096 error_report("Sector allocation test failed for %s", filename2);
1097 goto out;
1098 }
1099 nb_sectors = MIN(pnum1, pnum2);
1100
1101 if (allocated1 == allocated2) {
1102 if (allocated1) {
Max Reitzf1d3cd72015-02-05 13:58:18 -05001103 ret = blk_read(blk1, sector_num, buf1, nb_sectors);
Miroslav Rezaninad14ed182013-02-13 09:09:41 +01001104 if (ret < 0) {
1105 error_report("Error while reading offset %" PRId64 " of %s:"
1106 " %s", sectors_to_bytes(sector_num), filename1,
1107 strerror(-ret));
1108 ret = 4;
1109 goto out;
1110 }
Max Reitzf1d3cd72015-02-05 13:58:18 -05001111 ret = blk_read(blk2, sector_num, buf2, nb_sectors);
Miroslav Rezaninad14ed182013-02-13 09:09:41 +01001112 if (ret < 0) {
1113 error_report("Error while reading offset %" PRId64
1114 " of %s: %s", sectors_to_bytes(sector_num),
1115 filename2, strerror(-ret));
1116 ret = 4;
1117 goto out;
1118 }
1119 ret = compare_sectors(buf1, buf2, nb_sectors, &pnum);
1120 if (ret || pnum != nb_sectors) {
Miroslav Rezaninad14ed182013-02-13 09:09:41 +01001121 qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
1122 sectors_to_bytes(
1123 ret ? sector_num : sector_num + pnum));
Fam Zheng36452f12013-11-13 20:26:49 +08001124 ret = 1;
Miroslav Rezaninad14ed182013-02-13 09:09:41 +01001125 goto out;
1126 }
1127 }
1128 } else {
1129 if (strict) {
1130 ret = 1;
1131 qprintf(quiet, "Strict mode: Offset %" PRId64
1132 " allocation mismatch!\n",
1133 sectors_to_bytes(sector_num));
1134 goto out;
1135 }
1136
1137 if (allocated1) {
Max Reitzf1d3cd72015-02-05 13:58:18 -05001138 ret = check_empty_sectors(blk1, sector_num, nb_sectors,
Miroslav Rezaninad14ed182013-02-13 09:09:41 +01001139 filename1, buf1, quiet);
1140 } else {
Max Reitzf1d3cd72015-02-05 13:58:18 -05001141 ret = check_empty_sectors(blk2, sector_num, nb_sectors,
Miroslav Rezaninad14ed182013-02-13 09:09:41 +01001142 filename2, buf1, quiet);
1143 }
1144 if (ret) {
1145 if (ret < 0) {
Miroslav Rezaninad14ed182013-02-13 09:09:41 +01001146 error_report("Error while reading offset %" PRId64 ": %s",
1147 sectors_to_bytes(sector_num), strerror(-ret));
Fam Zheng36452f12013-11-13 20:26:49 +08001148 ret = 4;
Miroslav Rezaninad14ed182013-02-13 09:09:41 +01001149 }
1150 goto out;
1151 }
1152 }
1153 sector_num += nb_sectors;
1154 qemu_progress_print(((float) nb_sectors / progress_base)*100, 100);
1155 }
1156
1157 if (total_sectors1 != total_sectors2) {
Max Reitzf1d3cd72015-02-05 13:58:18 -05001158 BlockBackend *blk_over;
Miroslav Rezaninad14ed182013-02-13 09:09:41 +01001159 int64_t total_sectors_over;
1160 const char *filename_over;
1161
1162 qprintf(quiet, "Warning: Image size mismatch!\n");
1163 if (total_sectors1 > total_sectors2) {
1164 total_sectors_over = total_sectors1;
Max Reitzf1d3cd72015-02-05 13:58:18 -05001165 blk_over = blk1;
Miroslav Rezaninad14ed182013-02-13 09:09:41 +01001166 filename_over = filename1;
1167 } else {
1168 total_sectors_over = total_sectors2;
Max Reitzf1d3cd72015-02-05 13:58:18 -05001169 blk_over = blk2;
Miroslav Rezaninad14ed182013-02-13 09:09:41 +01001170 filename_over = filename2;
1171 }
1172
1173 for (;;) {
1174 nb_sectors = sectors_to_process(total_sectors_over, sector_num);
1175 if (nb_sectors <= 0) {
1176 break;
1177 }
Max Reitzf1d3cd72015-02-05 13:58:18 -05001178 ret = bdrv_is_allocated_above(blk_bs(blk_over), NULL, sector_num,
Miroslav Rezaninad14ed182013-02-13 09:09:41 +01001179 nb_sectors, &pnum);
1180 if (ret < 0) {
1181 ret = 3;
1182 error_report("Sector allocation test failed for %s",
1183 filename_over);
1184 goto out;
1185
1186 }
1187 nb_sectors = pnum;
1188 if (ret) {
Max Reitzf1d3cd72015-02-05 13:58:18 -05001189 ret = check_empty_sectors(blk_over, sector_num, nb_sectors,
Miroslav Rezaninad14ed182013-02-13 09:09:41 +01001190 filename_over, buf1, quiet);
1191 if (ret) {
1192 if (ret < 0) {
Miroslav Rezaninad14ed182013-02-13 09:09:41 +01001193 error_report("Error while reading offset %" PRId64
1194 " of %s: %s", sectors_to_bytes(sector_num),
1195 filename_over, strerror(-ret));
Fam Zheng36452f12013-11-13 20:26:49 +08001196 ret = 4;
Miroslav Rezaninad14ed182013-02-13 09:09:41 +01001197 }
1198 goto out;
1199 }
1200 }
1201 sector_num += nb_sectors;
1202 qemu_progress_print(((float) nb_sectors / progress_base)*100, 100);
1203 }
1204 }
1205
1206 qprintf(quiet, "Images are identical.\n");
1207 ret = 0;
1208
1209out:
Miroslav Rezaninad14ed182013-02-13 09:09:41 +01001210 qemu_vfree(buf1);
1211 qemu_vfree(buf2);
Markus Armbruster26f54e92014-10-07 13:59:04 +02001212 blk_unref(blk2);
Miroslav Rezaninad14ed182013-02-13 09:09:41 +01001213out2:
Markus Armbruster26f54e92014-10-07 13:59:04 +02001214 blk_unref(blk1);
Miroslav Rezaninad14ed182013-02-13 09:09:41 +01001215out3:
1216 qemu_progress_end();
1217 return ret;
1218}
1219
Kevin Wolf690c7302015-03-19 13:33:32 +01001220enum ImgConvertBlockStatus {
1221 BLK_DATA,
1222 BLK_ZERO,
1223 BLK_BACKING_FILE,
1224};
1225
1226typedef struct ImgConvertState {
1227 BlockBackend **src;
1228 int64_t *src_sectors;
1229 int src_cur, src_num;
1230 int64_t src_cur_offset;
1231 int64_t total_sectors;
1232 int64_t allocated_sectors;
1233 enum ImgConvertBlockStatus status;
1234 int64_t sector_next_status;
1235 BlockBackend *target;
1236 bool has_zero_init;
1237 bool compressed;
1238 bool target_has_backing;
1239 int min_sparse;
1240 size_t cluster_sectors;
1241 size_t buf_sectors;
1242} ImgConvertState;
1243
1244static void convert_select_part(ImgConvertState *s, int64_t sector_num)
1245{
1246 assert(sector_num >= s->src_cur_offset);
1247 while (sector_num - s->src_cur_offset >= s->src_sectors[s->src_cur]) {
1248 s->src_cur_offset += s->src_sectors[s->src_cur];
1249 s->src_cur++;
1250 assert(s->src_cur < s->src_num);
1251 }
1252}
1253
1254static int convert_iteration_sectors(ImgConvertState *s, int64_t sector_num)
1255{
1256 int64_t ret;
1257 int n;
1258
1259 convert_select_part(s, sector_num);
1260
1261 assert(s->total_sectors > sector_num);
1262 n = MIN(s->total_sectors - sector_num, BDRV_REQUEST_MAX_SECTORS);
1263
1264 if (s->sector_next_status <= sector_num) {
1265 ret = bdrv_get_block_status(blk_bs(s->src[s->src_cur]),
1266 sector_num - s->src_cur_offset,
1267 n, &n);
1268 if (ret < 0) {
1269 return ret;
1270 }
1271
1272 if (ret & BDRV_BLOCK_ZERO) {
1273 s->status = BLK_ZERO;
1274 } else if (ret & BDRV_BLOCK_DATA) {
1275 s->status = BLK_DATA;
1276 } else if (!s->target_has_backing) {
1277 /* Without a target backing file we must copy over the contents of
1278 * the backing file as well. */
1279 /* TODO Check block status of the backing file chain to avoid
1280 * needlessly reading zeroes and limiting the iteration to the
1281 * buffer size */
1282 s->status = BLK_DATA;
1283 } else {
1284 s->status = BLK_BACKING_FILE;
1285 }
1286
1287 s->sector_next_status = sector_num + n;
1288 }
1289
1290 n = MIN(n, s->sector_next_status - sector_num);
1291 if (s->status == BLK_DATA) {
1292 n = MIN(n, s->buf_sectors);
1293 }
1294
1295 /* We need to write complete clusters for compressed images, so if an
1296 * unallocated area is shorter than that, we must consider the whole
1297 * cluster allocated. */
1298 if (s->compressed) {
1299 if (n < s->cluster_sectors) {
1300 n = MIN(s->cluster_sectors, s->total_sectors - sector_num);
1301 s->status = BLK_DATA;
1302 } else {
1303 n = QEMU_ALIGN_DOWN(n, s->cluster_sectors);
1304 }
1305 }
1306
1307 return n;
1308}
1309
1310static int convert_read(ImgConvertState *s, int64_t sector_num, int nb_sectors,
1311 uint8_t *buf)
1312{
1313 int n;
1314 int ret;
1315
1316 if (s->status == BLK_ZERO || s->status == BLK_BACKING_FILE) {
1317 return 0;
1318 }
1319
1320 assert(nb_sectors <= s->buf_sectors);
1321 while (nb_sectors > 0) {
1322 BlockBackend *blk;
1323 int64_t bs_sectors;
1324
1325 /* In the case of compression with multiple source files, we can get a
1326 * nb_sectors that spreads into the next part. So we must be able to
1327 * read across multiple BDSes for one convert_read() call. */
1328 convert_select_part(s, sector_num);
1329 blk = s->src[s->src_cur];
1330 bs_sectors = s->src_sectors[s->src_cur];
1331
1332 n = MIN(nb_sectors, bs_sectors - (sector_num - s->src_cur_offset));
1333 ret = blk_read(blk, sector_num - s->src_cur_offset, buf, n);
1334 if (ret < 0) {
1335 return ret;
1336 }
1337
1338 sector_num += n;
1339 nb_sectors -= n;
1340 buf += n * BDRV_SECTOR_SIZE;
1341 }
1342
1343 return 0;
1344}
1345
1346static int convert_write(ImgConvertState *s, int64_t sector_num, int nb_sectors,
1347 const uint8_t *buf)
1348{
1349 int ret;
1350
1351 while (nb_sectors > 0) {
1352 int n = nb_sectors;
1353
1354 switch (s->status) {
1355 case BLK_BACKING_FILE:
1356 /* If we have a backing file, leave clusters unallocated that are
1357 * unallocated in the source image, so that the backing file is
1358 * visible at the respective offset. */
1359 assert(s->target_has_backing);
1360 break;
1361
1362 case BLK_DATA:
1363 /* We must always write compressed clusters as a whole, so don't
1364 * try to find zeroed parts in the buffer. We can only save the
1365 * write if the buffer is completely zeroed and we're allowed to
1366 * keep the target sparse. */
1367 if (s->compressed) {
1368 if (s->has_zero_init && s->min_sparse &&
1369 buffer_is_zero(buf, n * BDRV_SECTOR_SIZE))
1370 {
1371 assert(!s->target_has_backing);
1372 break;
1373 }
1374
1375 ret = blk_write_compressed(s->target, sector_num, buf, n);
1376 if (ret < 0) {
1377 return ret;
1378 }
1379 break;
1380 }
1381
1382 /* If there is real non-zero data or we're told to keep the target
1383 * fully allocated (-S 0), we must write it. Otherwise we can treat
1384 * it as zero sectors. */
1385 if (!s->min_sparse ||
1386 is_allocated_sectors_min(buf, n, &n, s->min_sparse))
1387 {
1388 ret = blk_write(s->target, sector_num, buf, n);
1389 if (ret < 0) {
1390 return ret;
1391 }
1392 break;
1393 }
1394 /* fall-through */
1395
1396 case BLK_ZERO:
1397 if (s->has_zero_init) {
1398 break;
1399 }
1400 ret = blk_write_zeroes(s->target, sector_num, n, 0);
1401 if (ret < 0) {
1402 return ret;
1403 }
1404 break;
1405 }
1406
1407 sector_num += n;
1408 nb_sectors -= n;
1409 buf += n * BDRV_SECTOR_SIZE;
1410 }
1411
1412 return 0;
1413}
1414
1415static int convert_do_copy(ImgConvertState *s)
1416{
1417 uint8_t *buf = NULL;
1418 int64_t sector_num, allocated_done;
1419 int ret;
1420 int n;
1421
1422 /* Check whether we have zero initialisation or can get it efficiently */
1423 s->has_zero_init = s->min_sparse && !s->target_has_backing
1424 ? bdrv_has_zero_init(blk_bs(s->target))
1425 : false;
1426
1427 if (!s->has_zero_init && !s->target_has_backing &&
1428 bdrv_can_write_zeroes_with_unmap(blk_bs(s->target)))
1429 {
1430 ret = bdrv_make_zero(blk_bs(s->target), BDRV_REQ_MAY_UNMAP);
1431 if (ret == 0) {
1432 s->has_zero_init = true;
1433 }
1434 }
1435
1436 /* Allocate buffer for copied data. For compressed images, only one cluster
1437 * can be copied at a time. */
1438 if (s->compressed) {
1439 if (s->cluster_sectors <= 0 || s->cluster_sectors > s->buf_sectors) {
1440 error_report("invalid cluster size");
1441 ret = -EINVAL;
1442 goto fail;
1443 }
1444 s->buf_sectors = s->cluster_sectors;
1445 }
1446 buf = blk_blockalign(s->target, s->buf_sectors * BDRV_SECTOR_SIZE);
1447
1448 /* Calculate allocated sectors for progress */
1449 s->allocated_sectors = 0;
1450 sector_num = 0;
1451 while (sector_num < s->total_sectors) {
1452 n = convert_iteration_sectors(s, sector_num);
1453 if (n < 0) {
1454 ret = n;
1455 goto fail;
1456 }
1457 if (s->status == BLK_DATA) {
1458 s->allocated_sectors += n;
1459 }
1460 sector_num += n;
1461 }
1462
1463 /* Do the copy */
1464 s->src_cur = 0;
1465 s->src_cur_offset = 0;
1466 s->sector_next_status = 0;
1467
1468 sector_num = 0;
1469 allocated_done = 0;
1470
1471 while (sector_num < s->total_sectors) {
1472 n = convert_iteration_sectors(s, sector_num);
1473 if (n < 0) {
1474 ret = n;
1475 goto fail;
1476 }
1477 if (s->status == BLK_DATA) {
1478 allocated_done += n;
1479 qemu_progress_print(100.0 * allocated_done / s->allocated_sectors,
1480 0);
1481 }
1482
1483 ret = convert_read(s, sector_num, n, buf);
1484 if (ret < 0) {
1485 error_report("error while reading sector %" PRId64
1486 ": %s", sector_num, strerror(-ret));
1487 goto fail;
1488 }
1489
1490 ret = convert_write(s, sector_num, n, buf);
1491 if (ret < 0) {
1492 error_report("error while writing sector %" PRId64
1493 ": %s", sector_num, strerror(-ret));
1494 goto fail;
1495 }
1496
1497 sector_num += n;
1498 }
1499
1500 if (s->compressed) {
1501 /* signal EOF to align */
1502 ret = blk_write_compressed(s->target, 0, NULL, 0);
1503 if (ret < 0) {
1504 goto fail;
1505 }
1506 }
1507
1508 ret = 0;
1509fail:
1510 qemu_vfree(buf);
1511 return ret;
1512}
1513
bellardea2384d2004-08-01 21:59:26 +00001514static int img_convert(int argc, char **argv)
1515{
Kevin Wolf690c7302015-03-19 13:33:32 +01001516 int c, bs_n, bs_i, compress, cluster_sectors, skip_create;
Peter Lieven13c28af2013-11-27 11:07:01 +01001517 int64_t ret = 0;
Max Reitz40055952014-07-22 22:58:42 +02001518 int progress = 0, flags, src_flags;
1519 const char *fmt, *out_fmt, *cache, *src_cache, *out_baseimg, *out_filename;
MORITA Kazutakab50cbab2010-05-26 11:35:36 +09001520 BlockDriver *drv, *proto_drv;
Markus Armbruster26f54e92014-10-07 13:59:04 +02001521 BlockBackend **blk = NULL, *out_blk = NULL;
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001522 BlockDriverState **bs = NULL, *out_bs = NULL;
Kevin Wolf690c7302015-03-19 13:33:32 +01001523 int64_t total_sectors;
Markus Armbruster52bf1e72014-06-26 13:23:25 +02001524 int64_t *bs_sectors = NULL;
Peter Lievenf2521c92013-11-27 11:07:06 +01001525 size_t bufsectors = IO_BUF_SIZE / BDRV_SECTOR_SIZE;
bellardfaea38e2006-08-05 21:31:00 +00001526 BlockDriverInfo bdi;
Chunyan Liu83d05212014-06-05 17:20:51 +08001527 QemuOpts *opts = NULL;
1528 QemuOptsList *create_opts = NULL;
1529 const char *out_baseimg_param;
Kevin Wolfefa84d42009-05-18 16:42:12 +02001530 char *options = NULL;
edison51ef6722010-09-21 19:58:41 -07001531 const char *snapshot_name = NULL;
Kevin Wolfa22f1232011-08-26 15:27:13 +02001532 int min_sparse = 8; /* Need at least 4k of zeros for sparse detection */
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01001533 bool quiet = false;
Max Reitzcc84d902013-09-06 17:14:26 +02001534 Error *local_err = NULL;
Wenchao Xiaef806542013-12-04 17:10:57 +08001535 QemuOpts *sn_opts = NULL;
Kevin Wolf690c7302015-03-19 13:33:32 +01001536 ImgConvertState state;
bellardea2384d2004-08-01 21:59:26 +00001537
1538 fmt = NULL;
1539 out_fmt = "raw";
Federico Simoncelli661a0f72011-06-20 12:48:19 -04001540 cache = "unsafe";
Max Reitz40055952014-07-22 22:58:42 +02001541 src_cache = BDRV_DEFAULT_CACHE;
thsf58c7b32008-06-05 21:53:49 +00001542 out_baseimg = NULL;
Jes Sorenseneec77d92010-12-07 17:44:34 +01001543 compress = 0;
Alexandre Derumierb2e10492013-09-02 19:07:24 +01001544 skip_create = 0;
bellardea2384d2004-08-01 21:59:26 +00001545 for(;;) {
Max Reitz40055952014-07-22 22:58:42 +02001546 c = getopt(argc, argv, "hf:O:B:ce6o:s:l:S:pt:T:qn");
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001547 if (c == -1) {
bellardea2384d2004-08-01 21:59:26 +00001548 break;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01001549 }
bellardea2384d2004-08-01 21:59:26 +00001550 switch(c) {
Jes Sorensenef873942010-12-06 15:25:40 +01001551 case '?':
bellardea2384d2004-08-01 21:59:26 +00001552 case 'h':
1553 help();
1554 break;
1555 case 'f':
1556 fmt = optarg;
1557 break;
1558 case 'O':
1559 out_fmt = optarg;
1560 break;
thsf58c7b32008-06-05 21:53:49 +00001561 case 'B':
1562 out_baseimg = optarg;
1563 break;
bellardea2384d2004-08-01 21:59:26 +00001564 case 'c':
Jes Sorenseneec77d92010-12-07 17:44:34 +01001565 compress = 1;
bellardea2384d2004-08-01 21:59:26 +00001566 break;
1567 case 'e':
Markus Armbruster9d42e152011-06-22 14:03:55 +02001568 error_report("option -e is deprecated, please use \'-o "
Jes Sorenseneec77d92010-12-07 17:44:34 +01001569 "encryption\' instead!");
Kevin Wolf2dc83282014-02-21 16:24:05 +01001570 ret = -1;
Kevin Wolf64bb01a2014-03-03 14:54:07 +01001571 goto fail_getopt;
thsec36ba12007-09-16 21:59:02 +00001572 case '6':
Markus Armbruster9d42e152011-06-22 14:03:55 +02001573 error_report("option -6 is deprecated, please use \'-o "
Jes Sorenseneec77d92010-12-07 17:44:34 +01001574 "compat6\' instead!");
Kevin Wolf2dc83282014-02-21 16:24:05 +01001575 ret = -1;
Kevin Wolf64bb01a2014-03-03 14:54:07 +01001576 goto fail_getopt;
Kevin Wolfefa84d42009-05-18 16:42:12 +02001577 case 'o':
Kevin Wolf2dc83282014-02-21 16:24:05 +01001578 if (!is_valid_option_list(optarg)) {
1579 error_report("Invalid option list: %s", optarg);
1580 ret = -1;
Kevin Wolf64bb01a2014-03-03 14:54:07 +01001581 goto fail_getopt;
Kevin Wolf2dc83282014-02-21 16:24:05 +01001582 }
1583 if (!options) {
1584 options = g_strdup(optarg);
1585 } else {
1586 char *old_options = options;
1587 options = g_strdup_printf("%s,%s", options, optarg);
1588 g_free(old_options);
1589 }
Kevin Wolfefa84d42009-05-18 16:42:12 +02001590 break;
edison51ef6722010-09-21 19:58:41 -07001591 case 's':
1592 snapshot_name = optarg;
1593 break;
Wenchao Xiaef806542013-12-04 17:10:57 +08001594 case 'l':
1595 if (strstart(optarg, SNAPSHOT_OPT_BASE, NULL)) {
Markus Armbruster70b94332015-02-13 12:50:26 +01001596 sn_opts = qemu_opts_parse_noisily(&internal_snapshot_opts,
1597 optarg, false);
Wenchao Xiaef806542013-12-04 17:10:57 +08001598 if (!sn_opts) {
1599 error_report("Failed in parsing snapshot param '%s'",
1600 optarg);
Kevin Wolf2dc83282014-02-21 16:24:05 +01001601 ret = -1;
Kevin Wolf64bb01a2014-03-03 14:54:07 +01001602 goto fail_getopt;
Wenchao Xiaef806542013-12-04 17:10:57 +08001603 }
1604 } else {
1605 snapshot_name = optarg;
1606 }
1607 break;
Kevin Wolfa22f1232011-08-26 15:27:13 +02001608 case 'S':
1609 {
1610 int64_t sval;
Markus Armbrustere36b3692011-11-22 09:46:05 +01001611 char *end;
Marc-André Lureau4677bb42015-09-16 18:02:56 +02001612 sval = qemu_strtosz_suffix(optarg, &end, QEMU_STRTOSZ_DEFSUFFIX_B);
Markus Armbrustere36b3692011-11-22 09:46:05 +01001613 if (sval < 0 || *end) {
Kevin Wolfa22f1232011-08-26 15:27:13 +02001614 error_report("Invalid minimum zero buffer size for sparse output specified");
Kevin Wolf2dc83282014-02-21 16:24:05 +01001615 ret = -1;
Kevin Wolf64bb01a2014-03-03 14:54:07 +01001616 goto fail_getopt;
Kevin Wolfa22f1232011-08-26 15:27:13 +02001617 }
1618
1619 min_sparse = sval / BDRV_SECTOR_SIZE;
1620 break;
1621 }
Jes Sorensen6b837bc2011-03-30 14:16:25 +02001622 case 'p':
1623 progress = 1;
1624 break;
Federico Simoncelli661a0f72011-06-20 12:48:19 -04001625 case 't':
1626 cache = optarg;
1627 break;
Max Reitz40055952014-07-22 22:58:42 +02001628 case 'T':
1629 src_cache = optarg;
1630 break;
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01001631 case 'q':
1632 quiet = true;
1633 break;
Alexandre Derumierb2e10492013-09-02 19:07:24 +01001634 case 'n':
1635 skip_create = 1;
1636 break;
bellardea2384d2004-08-01 21:59:26 +00001637 }
1638 }
ths3b46e622007-09-17 08:09:54 +00001639
Kevin Wolf64bb01a2014-03-03 14:54:07 +01001640 /* Initialize before goto out */
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01001641 if (quiet) {
1642 progress = 0;
1643 }
Kevin Wolf64bb01a2014-03-03 14:54:07 +01001644 qemu_progress_init(progress, 1.0);
1645
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01001646
balrog926c2d22007-10-31 01:11:44 +00001647 bs_n = argc - optind - 1;
Kevin Wolfa283cb62014-02-21 16:24:07 +01001648 out_filename = bs_n >= 1 ? argv[argc - 1] : NULL;
thsf58c7b32008-06-05 21:53:49 +00001649
Kevin Wolf2dc83282014-02-21 16:24:05 +01001650 if (options && has_help_option(options)) {
Jes Sorensen4ac8aac2010-12-06 15:25:38 +01001651 ret = print_block_option_help(out_filename, out_fmt);
1652 goto out;
1653 }
1654
bellardea2384d2004-08-01 21:59:26 +00001655 if (bs_n < 1) {
Fam Zhengac1307a2014-04-22 13:36:11 +08001656 error_exit("Must specify image file name");
ths5fafdf22007-09-16 21:08:06 +00001657 }
bellardea2384d2004-08-01 21:59:26 +00001658
thsf58c7b32008-06-05 21:53:49 +00001659
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001660 if (bs_n > 1 && out_baseimg) {
Jes Sorensen15654a62010-12-16 14:31:53 +01001661 error_report("-B makes no sense when concatenating multiple input "
1662 "images");
Jes Sorensen31ca34b2010-12-06 15:25:36 +01001663 ret = -1;
1664 goto out;
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001665 }
Dong Xu Wangf8111c22012-03-15 20:13:31 +08001666
Max Reitz40055952014-07-22 22:58:42 +02001667 src_flags = BDRV_O_FLAGS;
1668 ret = bdrv_parse_cache_flags(src_cache, &src_flags);
1669 if (ret < 0) {
1670 error_report("Invalid source cache option: %s", src_cache);
1671 goto out;
1672 }
1673
Jes Sorensen6b837bc2011-03-30 14:16:25 +02001674 qemu_progress_print(0, 100);
1675
Markus Armbruster26f54e92014-10-07 13:59:04 +02001676 blk = g_new0(BlockBackend *, bs_n);
Markus Armbrusterd739f1c2014-06-26 13:23:24 +02001677 bs = g_new0(BlockDriverState *, bs_n);
Markus Armbruster52bf1e72014-06-26 13:23:25 +02001678 bs_sectors = g_new(int64_t, bs_n);
balrog926c2d22007-10-31 01:11:44 +00001679
1680 total_sectors = 0;
1681 for (bs_i = 0; bs_i < bs_n; bs_i++) {
Kevin Wolf9aebf3b2014-09-25 09:54:02 +02001682 char *id = bs_n > 1 ? g_strdup_printf("source_%d", bs_i)
Kevin Wolf9ffe3332014-04-17 16:57:13 +02001683 : g_strdup("source");
Markus Armbruster7e7d56d2014-10-07 13:59:05 +02001684 blk[bs_i] = img_open(id, argv[optind + bs_i], fmt, src_flags,
1685 true, quiet);
Kevin Wolf9ffe3332014-04-17 16:57:13 +02001686 g_free(id);
Markus Armbruster7e7d56d2014-10-07 13:59:05 +02001687 if (!blk[bs_i]) {
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001688 ret = -1;
1689 goto out;
1690 }
Markus Armbruster7e7d56d2014-10-07 13:59:05 +02001691 bs[bs_i] = blk_bs(blk[bs_i]);
Max Reitzf1d3cd72015-02-05 13:58:18 -05001692 bs_sectors[bs_i] = blk_nb_sectors(blk[bs_i]);
Markus Armbruster52bf1e72014-06-26 13:23:25 +02001693 if (bs_sectors[bs_i] < 0) {
1694 error_report("Could not get size of %s: %s",
1695 argv[optind + bs_i], strerror(-bs_sectors[bs_i]));
1696 ret = -1;
1697 goto out;
1698 }
Markus Armbrusterd739f1c2014-06-26 13:23:24 +02001699 total_sectors += bs_sectors[bs_i];
balrog926c2d22007-10-31 01:11:44 +00001700 }
bellardea2384d2004-08-01 21:59:26 +00001701
Wenchao Xiaef806542013-12-04 17:10:57 +08001702 if (sn_opts) {
1703 ret = bdrv_snapshot_load_tmp(bs[0],
1704 qemu_opt_get(sn_opts, SNAPSHOT_OPT_ID),
1705 qemu_opt_get(sn_opts, SNAPSHOT_OPT_NAME),
1706 &local_err);
1707 } else if (snapshot_name != NULL) {
edison51ef6722010-09-21 19:58:41 -07001708 if (bs_n > 1) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001709 error_report("No support for concatenating multiple snapshot");
edison51ef6722010-09-21 19:58:41 -07001710 ret = -1;
1711 goto out;
1712 }
Wenchao Xia7b4c4782013-12-04 17:10:54 +08001713
1714 bdrv_snapshot_load_tmp_by_id_or_name(bs[0], snapshot_name, &local_err);
Wenchao Xiaef806542013-12-04 17:10:57 +08001715 }
Markus Armbruster84d18f02014-01-30 15:07:28 +01001716 if (local_err) {
Wenchao Xiaef806542013-12-04 17:10:57 +08001717 error_report("Failed to load snapshot: %s",
1718 error_get_pretty(local_err));
1719 error_free(local_err);
1720 ret = -1;
1721 goto out;
edison51ef6722010-09-21 19:58:41 -07001722 }
1723
Kevin Wolfefa84d42009-05-18 16:42:12 +02001724 /* Find driver and parse its options */
bellardea2384d2004-08-01 21:59:26 +00001725 drv = bdrv_find_format(out_fmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001726 if (!drv) {
Jes Sorensen15654a62010-12-16 14:31:53 +01001727 error_report("Unknown file format '%s'", out_fmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001728 ret = -1;
1729 goto out;
1730 }
balrog926c2d22007-10-31 01:11:44 +00001731
Max Reitzb65a5e12015-02-05 13:58:12 -05001732 proto_drv = bdrv_find_protocol(out_filename, true, &local_err);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001733 if (!proto_drv) {
Markus Armbruster2867ce42015-03-12 16:08:02 +01001734 error_report_err(local_err);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001735 ret = -1;
1736 goto out;
1737 }
MORITA Kazutakab50cbab2010-05-26 11:35:36 +09001738
Max Reitz2e024cd2015-02-11 09:58:46 -05001739 if (!skip_create) {
1740 if (!drv->create_opts) {
1741 error_report("Format driver '%s' does not support image creation",
1742 drv->format_name);
1743 ret = -1;
1744 goto out;
1745 }
Max Reitzf75613c2014-12-02 18:32:46 +01001746
Max Reitz2e024cd2015-02-11 09:58:46 -05001747 if (!proto_drv->create_opts) {
1748 error_report("Protocol driver '%s' does not support image creation",
1749 proto_drv->format_name);
1750 ret = -1;
1751 goto out;
1752 }
Max Reitzf75613c2014-12-02 18:32:46 +01001753
Max Reitz2e024cd2015-02-11 09:58:46 -05001754 create_opts = qemu_opts_append(create_opts, drv->create_opts);
1755 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
Kevin Wolfdb08adf2009-06-04 15:39:38 +02001756
Max Reitz2e024cd2015-02-11 09:58:46 -05001757 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
Markus Armbrusterdc523cd342015-02-12 18:37:11 +01001758 if (options) {
1759 qemu_opts_do_parse(opts, options, NULL, &local_err);
1760 if (local_err) {
Markus Armbruster97a2ca72015-03-14 10:23:15 +01001761 error_report_err(local_err);
Markus Armbrusterdc523cd342015-02-12 18:37:11 +01001762 ret = -1;
1763 goto out;
1764 }
Max Reitz2e024cd2015-02-11 09:58:46 -05001765 }
Kevin Wolfefa84d42009-05-18 16:42:12 +02001766
Markus Armbruster39101f22015-02-12 16:46:36 +01001767 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_sectors * 512,
1768 &error_abort);
Max Reitz2e024cd2015-02-11 09:58:46 -05001769 ret = add_old_style_options(out_fmt, opts, out_baseimg, NULL);
1770 if (ret < 0) {
1771 goto out;
1772 }
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001773 }
Kevin Wolfefa84d42009-05-18 16:42:12 +02001774
Kevin Wolfa18953f2010-10-14 15:46:04 +02001775 /* Get backing file name if -o backing_file was used */
Chunyan Liu83d05212014-06-05 17:20:51 +08001776 out_baseimg_param = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
Kevin Wolfa18953f2010-10-14 15:46:04 +02001777 if (out_baseimg_param) {
Chunyan Liu83d05212014-06-05 17:20:51 +08001778 out_baseimg = out_baseimg_param;
Kevin Wolfa18953f2010-10-14 15:46:04 +02001779 }
1780
Kevin Wolfefa84d42009-05-18 16:42:12 +02001781 /* Check if compression is supported */
Jes Sorenseneec77d92010-12-07 17:44:34 +01001782 if (compress) {
Chunyan Liu83d05212014-06-05 17:20:51 +08001783 bool encryption =
1784 qemu_opt_get_bool(opts, BLOCK_OPT_ENCRYPT, false);
1785 const char *preallocation =
1786 qemu_opt_get(opts, BLOCK_OPT_PREALLOC);
Kevin Wolfefa84d42009-05-18 16:42:12 +02001787
1788 if (!drv->bdrv_write_compressed) {
Jes Sorensen15654a62010-12-16 14:31:53 +01001789 error_report("Compression not supported for this file format");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001790 ret = -1;
1791 goto out;
Kevin Wolfefa84d42009-05-18 16:42:12 +02001792 }
1793
Chunyan Liu83d05212014-06-05 17:20:51 +08001794 if (encryption) {
Jes Sorensen15654a62010-12-16 14:31:53 +01001795 error_report("Compression and encryption not supported at "
1796 "the same time");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001797 ret = -1;
1798 goto out;
Kevin Wolfefa84d42009-05-18 16:42:12 +02001799 }
Kevin Wolf41521fa2011-10-18 16:19:42 +02001800
Chunyan Liu83d05212014-06-05 17:20:51 +08001801 if (preallocation
1802 && strcmp(preallocation, "off"))
Kevin Wolf41521fa2011-10-18 16:19:42 +02001803 {
1804 error_report("Compression and preallocation not supported at "
1805 "the same time");
1806 ret = -1;
1807 goto out;
1808 }
Kevin Wolfefa84d42009-05-18 16:42:12 +02001809 }
1810
Alexandre Derumierb2e10492013-09-02 19:07:24 +01001811 if (!skip_create) {
1812 /* Create the new image */
Chunyan Liuc282e1f2014-06-05 17:21:11 +08001813 ret = bdrv_create(drv, out_filename, opts, &local_err);
Alexandre Derumierb2e10492013-09-02 19:07:24 +01001814 if (ret < 0) {
Max Reitzcc84d902013-09-06 17:14:26 +02001815 error_report("%s: error while converting %s: %s",
1816 out_filename, out_fmt, error_get_pretty(local_err));
1817 error_free(local_err);
Alexandre Derumierb2e10492013-09-02 19:07:24 +01001818 goto out;
bellardea2384d2004-08-01 21:59:26 +00001819 }
1820 }
ths3b46e622007-09-17 08:09:54 +00001821
Peter Lieven5a37b602013-10-24 12:07:06 +02001822 flags = min_sparse ? (BDRV_O_RDWR | BDRV_O_UNMAP) : BDRV_O_RDWR;
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +01001823 ret = bdrv_parse_cache_flags(cache, &flags);
Federico Simoncelli661a0f72011-06-20 12:48:19 -04001824 if (ret < 0) {
1825 error_report("Invalid cache option: %s", cache);
Markus Armbrusterbb9cd2e2014-05-28 11:17:07 +02001826 goto out;
Federico Simoncelli661a0f72011-06-20 12:48:19 -04001827 }
1828
Markus Armbruster7e7d56d2014-10-07 13:59:05 +02001829 out_blk = img_open("target", out_filename, out_fmt, flags, true, quiet);
1830 if (!out_blk) {
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001831 ret = -1;
1832 goto out;
1833 }
Markus Armbruster7e7d56d2014-10-07 13:59:05 +02001834 out_bs = blk_bs(out_blk);
bellardea2384d2004-08-01 21:59:26 +00001835
Peter Lievenf2521c92013-11-27 11:07:06 +01001836 /* increase bufsectors from the default 4096 (2M) if opt_transfer_length
1837 * or discard_alignment of the out_bs is greater. Limit to 32768 (16MB)
1838 * as maximum. */
1839 bufsectors = MIN(32768,
1840 MAX(bufsectors, MAX(out_bs->bl.opt_transfer_length,
1841 out_bs->bl.discard_alignment))
1842 );
1843
Alexandre Derumierb2e10492013-09-02 19:07:24 +01001844 if (skip_create) {
Max Reitzf1d3cd72015-02-05 13:58:18 -05001845 int64_t output_sectors = blk_nb_sectors(out_blk);
Markus Armbruster43716fa2014-06-26 13:23:21 +02001846 if (output_sectors < 0) {
Gongleieec5eb42015-02-25 12:22:27 +08001847 error_report("unable to get output image length: %s",
Markus Armbruster43716fa2014-06-26 13:23:21 +02001848 strerror(-output_sectors));
Alexandre Derumierb2e10492013-09-02 19:07:24 +01001849 ret = -1;
1850 goto out;
Markus Armbruster43716fa2014-06-26 13:23:21 +02001851 } else if (output_sectors < total_sectors) {
Alexandre Derumierb2e10492013-09-02 19:07:24 +01001852 error_report("output file is smaller than input file");
1853 ret = -1;
1854 goto out;
1855 }
1856 }
1857
Peter Lieven24f833c2013-11-27 11:07:07 +01001858 cluster_sectors = 0;
1859 ret = bdrv_get_info(out_bs, &bdi);
1860 if (ret < 0) {
1861 if (compress) {
Jes Sorensen15654a62010-12-16 14:31:53 +01001862 error_report("could not get block driver info");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001863 goto out;
1864 }
Peter Lieven24f833c2013-11-27 11:07:07 +01001865 } else {
Fam Zheng85f49ca2014-05-06 21:08:43 +08001866 compress = compress || bdi.needs_compressed_writes;
Peter Lieven24f833c2013-11-27 11:07:07 +01001867 cluster_sectors = bdi.cluster_size / BDRV_SECTOR_SIZE;
1868 }
1869
Kevin Wolf690c7302015-03-19 13:33:32 +01001870 state = (ImgConvertState) {
1871 .src = blk,
1872 .src_sectors = bs_sectors,
1873 .src_num = bs_n,
1874 .total_sectors = total_sectors,
1875 .target = out_blk,
1876 .compressed = compress,
1877 .target_has_backing = (bool) out_baseimg,
1878 .min_sparse = min_sparse,
1879 .cluster_sectors = cluster_sectors,
1880 .buf_sectors = bufsectors,
1881 };
1882 ret = convert_do_copy(&state);
Jes Sorensen6b837bc2011-03-30 14:16:25 +02001883
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001884out:
Peter Lieven13c28af2013-11-27 11:07:01 +01001885 if (!ret) {
1886 qemu_progress_print(100, 0);
1887 }
Jes Sorensen6b837bc2011-03-30 14:16:25 +02001888 qemu_progress_end();
Chunyan Liu83d05212014-06-05 17:20:51 +08001889 qemu_opts_del(opts);
1890 qemu_opts_free(create_opts);
Markus Armbrusterfbf28a42014-09-29 16:07:55 +02001891 qemu_opts_del(sn_opts);
Markus Armbruster26f54e92014-10-07 13:59:04 +02001892 blk_unref(out_blk);
Markus Armbruster9ba10c92014-10-07 13:59:08 +02001893 g_free(bs);
Markus Armbruster26f54e92014-10-07 13:59:04 +02001894 if (blk) {
1895 for (bs_i = 0; bs_i < bs_n; bs_i++) {
1896 blk_unref(blk[bs_i]);
1897 }
1898 g_free(blk);
1899 }
Markus Armbrusterd739f1c2014-06-26 13:23:24 +02001900 g_free(bs_sectors);
Kevin Wolf64bb01a2014-03-03 14:54:07 +01001901fail_getopt:
1902 g_free(options);
1903
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09001904 if (ret) {
1905 return 1;
1906 }
bellardea2384d2004-08-01 21:59:26 +00001907 return 0;
1908}
1909
bellard57d1a2b2004-08-03 21:15:11 +00001910
bellardfaea38e2006-08-05 21:31:00 +00001911static void dump_snapshots(BlockDriverState *bs)
1912{
1913 QEMUSnapshotInfo *sn_tab, *sn;
1914 int nb_sns, i;
bellardfaea38e2006-08-05 21:31:00 +00001915
1916 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1917 if (nb_sns <= 0)
1918 return;
1919 printf("Snapshot list:\n");
Wenchao Xia5b917042013-05-25 11:09:45 +08001920 bdrv_snapshot_dump(fprintf, stdout, NULL);
1921 printf("\n");
bellardfaea38e2006-08-05 21:31:00 +00001922 for(i = 0; i < nb_sns; i++) {
1923 sn = &sn_tab[i];
Wenchao Xia5b917042013-05-25 11:09:45 +08001924 bdrv_snapshot_dump(fprintf, stdout, sn);
1925 printf("\n");
bellardfaea38e2006-08-05 21:31:00 +00001926 }
Anthony Liguori7267c092011-08-20 22:09:37 -05001927 g_free(sn_tab);
bellardfaea38e2006-08-05 21:31:00 +00001928}
1929
Stefan Hajnoczi9699bf02012-10-17 14:02:31 +02001930static void dump_json_image_info_list(ImageInfoList *list)
1931{
Markus Armbruster4399c432014-04-25 16:50:32 +02001932 Error *local_err = NULL;
Stefan Hajnoczi9699bf02012-10-17 14:02:31 +02001933 QString *str;
1934 QmpOutputVisitor *ov = qmp_output_visitor_new();
1935 QObject *obj;
1936 visit_type_ImageInfoList(qmp_output_get_visitor(ov),
Markus Armbruster4399c432014-04-25 16:50:32 +02001937 &list, NULL, &local_err);
Stefan Hajnoczi9699bf02012-10-17 14:02:31 +02001938 obj = qmp_output_get_qobject(ov);
1939 str = qobject_to_json_pretty(obj);
1940 assert(str != NULL);
1941 printf("%s\n", qstring_get_str(str));
1942 qobject_decref(obj);
1943 qmp_output_visitor_cleanup(ov);
1944 QDECREF(str);
1945}
1946
Benoît Canetc054b3f2012-09-05 13:09:02 +02001947static void dump_json_image_info(ImageInfo *info)
1948{
Markus Armbruster4399c432014-04-25 16:50:32 +02001949 Error *local_err = NULL;
Benoît Canetc054b3f2012-09-05 13:09:02 +02001950 QString *str;
1951 QmpOutputVisitor *ov = qmp_output_visitor_new();
1952 QObject *obj;
1953 visit_type_ImageInfo(qmp_output_get_visitor(ov),
Markus Armbruster4399c432014-04-25 16:50:32 +02001954 &info, NULL, &local_err);
Benoît Canetc054b3f2012-09-05 13:09:02 +02001955 obj = qmp_output_get_qobject(ov);
1956 str = qobject_to_json_pretty(obj);
1957 assert(str != NULL);
1958 printf("%s\n", qstring_get_str(str));
1959 qobject_decref(obj);
1960 qmp_output_visitor_cleanup(ov);
1961 QDECREF(str);
1962}
1963
Stefan Hajnoczi9699bf02012-10-17 14:02:31 +02001964static void dump_human_image_info_list(ImageInfoList *list)
1965{
1966 ImageInfoList *elem;
1967 bool delim = false;
1968
1969 for (elem = list; elem; elem = elem->next) {
1970 if (delim) {
1971 printf("\n");
1972 }
1973 delim = true;
1974
Wenchao Xia5b917042013-05-25 11:09:45 +08001975 bdrv_image_info_dump(fprintf, stdout, elem->value);
Stefan Hajnoczi9699bf02012-10-17 14:02:31 +02001976 }
1977}
1978
1979static gboolean str_equal_func(gconstpointer a, gconstpointer b)
1980{
1981 return strcmp(a, b) == 0;
1982}
1983
1984/**
1985 * Open an image file chain and return an ImageInfoList
1986 *
1987 * @filename: topmost image filename
1988 * @fmt: topmost image format (may be NULL to autodetect)
1989 * @chain: true - enumerate entire backing file chain
1990 * false - only topmost image file
1991 *
1992 * Returns a list of ImageInfo objects or NULL if there was an error opening an
1993 * image file. If there was an error a message will have been printed to
1994 * stderr.
1995 */
1996static ImageInfoList *collect_image_info_list(const char *filename,
1997 const char *fmt,
1998 bool chain)
1999{
2000 ImageInfoList *head = NULL;
2001 ImageInfoList **last = &head;
2002 GHashTable *filenames;
Wenchao Xia43526ec2013-06-06 12:27:58 +08002003 Error *err = NULL;
Stefan Hajnoczi9699bf02012-10-17 14:02:31 +02002004
2005 filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL);
2006
2007 while (filename) {
Markus Armbruster26f54e92014-10-07 13:59:04 +02002008 BlockBackend *blk;
Stefan Hajnoczi9699bf02012-10-17 14:02:31 +02002009 BlockDriverState *bs;
2010 ImageInfo *info;
2011 ImageInfoList *elem;
2012
2013 if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) {
2014 error_report("Backing file '%s' creates an infinite loop.",
2015 filename);
2016 goto err;
2017 }
2018 g_hash_table_insert(filenames, (gpointer)filename, NULL);
2019
Markus Armbruster7e7d56d2014-10-07 13:59:05 +02002020 blk = img_open("image", filename, fmt,
2021 BDRV_O_FLAGS | BDRV_O_NO_BACKING, false, false);
2022 if (!blk) {
Stefan Hajnoczi9699bf02012-10-17 14:02:31 +02002023 goto err;
2024 }
Markus Armbruster7e7d56d2014-10-07 13:59:05 +02002025 bs = blk_bs(blk);
Stefan Hajnoczi9699bf02012-10-17 14:02:31 +02002026
Wenchao Xia43526ec2013-06-06 12:27:58 +08002027 bdrv_query_image_info(bs, &info, &err);
Markus Armbruster84d18f02014-01-30 15:07:28 +01002028 if (err) {
Markus Armbruster565f65d2015-02-12 13:55:05 +01002029 error_report_err(err);
Markus Armbruster26f54e92014-10-07 13:59:04 +02002030 blk_unref(blk);
Wenchao Xia43526ec2013-06-06 12:27:58 +08002031 goto err;
Wenchao Xiafb0ed452013-06-06 12:27:57 +08002032 }
Stefan Hajnoczi9699bf02012-10-17 14:02:31 +02002033
2034 elem = g_new0(ImageInfoList, 1);
2035 elem->value = info;
2036 *last = elem;
2037 last = &elem->next;
2038
Markus Armbruster26f54e92014-10-07 13:59:04 +02002039 blk_unref(blk);
Stefan Hajnoczi9699bf02012-10-17 14:02:31 +02002040
2041 filename = fmt = NULL;
2042 if (chain) {
2043 if (info->has_full_backing_filename) {
2044 filename = info->full_backing_filename;
2045 } else if (info->has_backing_filename) {
2046 filename = info->backing_filename;
2047 }
2048 if (info->has_backing_filename_format) {
2049 fmt = info->backing_filename_format;
2050 }
2051 }
2052 }
2053 g_hash_table_destroy(filenames);
2054 return head;
2055
2056err:
2057 qapi_free_ImageInfoList(head);
2058 g_hash_table_destroy(filenames);
2059 return NULL;
2060}
2061
Benoît Canetc054b3f2012-09-05 13:09:02 +02002062static int img_info(int argc, char **argv)
2063{
2064 int c;
2065 OutputFormat output_format = OFORMAT_HUMAN;
Stefan Hajnoczi9699bf02012-10-17 14:02:31 +02002066 bool chain = false;
Benoît Canetc054b3f2012-09-05 13:09:02 +02002067 const char *filename, *fmt, *output;
Stefan Hajnoczi9699bf02012-10-17 14:02:31 +02002068 ImageInfoList *list;
Benoît Canetc054b3f2012-09-05 13:09:02 +02002069
bellardea2384d2004-08-01 21:59:26 +00002070 fmt = NULL;
Benoît Canetc054b3f2012-09-05 13:09:02 +02002071 output = NULL;
bellardea2384d2004-08-01 21:59:26 +00002072 for(;;) {
Benoît Canetc054b3f2012-09-05 13:09:02 +02002073 int option_index = 0;
2074 static const struct option long_options[] = {
2075 {"help", no_argument, 0, 'h'},
2076 {"format", required_argument, 0, 'f'},
2077 {"output", required_argument, 0, OPTION_OUTPUT},
Stefan Hajnoczi9699bf02012-10-17 14:02:31 +02002078 {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN},
Benoît Canetc054b3f2012-09-05 13:09:02 +02002079 {0, 0, 0, 0}
2080 };
2081 c = getopt_long(argc, argv, "f:h",
2082 long_options, &option_index);
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01002083 if (c == -1) {
bellardea2384d2004-08-01 21:59:26 +00002084 break;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01002085 }
bellardea2384d2004-08-01 21:59:26 +00002086 switch(c) {
Jes Sorensenef873942010-12-06 15:25:40 +01002087 case '?':
bellardea2384d2004-08-01 21:59:26 +00002088 case 'h':
2089 help();
2090 break;
2091 case 'f':
2092 fmt = optarg;
2093 break;
Benoît Canetc054b3f2012-09-05 13:09:02 +02002094 case OPTION_OUTPUT:
2095 output = optarg;
2096 break;
Stefan Hajnoczi9699bf02012-10-17 14:02:31 +02002097 case OPTION_BACKING_CHAIN:
2098 chain = true;
2099 break;
bellardea2384d2004-08-01 21:59:26 +00002100 }
2101 }
Kevin Wolffc11eb22013-08-05 10:53:04 +02002102 if (optind != argc - 1) {
Fam Zhengac1307a2014-04-22 13:36:11 +08002103 error_exit("Expecting one image file name");
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01002104 }
bellardea2384d2004-08-01 21:59:26 +00002105 filename = argv[optind++];
2106
Benoît Canetc054b3f2012-09-05 13:09:02 +02002107 if (output && !strcmp(output, "json")) {
2108 output_format = OFORMAT_JSON;
2109 } else if (output && !strcmp(output, "human")) {
2110 output_format = OFORMAT_HUMAN;
2111 } else if (output) {
2112 error_report("--output must be used with human or json as argument.");
2113 return 1;
2114 }
2115
Stefan Hajnoczi9699bf02012-10-17 14:02:31 +02002116 list = collect_image_info_list(filename, fmt, chain);
2117 if (!list) {
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09002118 return 1;
2119 }
Benoît Canetc054b3f2012-09-05 13:09:02 +02002120
Benoît Canetc054b3f2012-09-05 13:09:02 +02002121 switch (output_format) {
2122 case OFORMAT_HUMAN:
Stefan Hajnoczi9699bf02012-10-17 14:02:31 +02002123 dump_human_image_info_list(list);
Benoît Canetc054b3f2012-09-05 13:09:02 +02002124 break;
2125 case OFORMAT_JSON:
Stefan Hajnoczi9699bf02012-10-17 14:02:31 +02002126 if (chain) {
2127 dump_json_image_info_list(list);
2128 } else {
2129 dump_json_image_info(list->value);
2130 }
Benoît Canetc054b3f2012-09-05 13:09:02 +02002131 break;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01002132 }
Benoît Canetc054b3f2012-09-05 13:09:02 +02002133
Stefan Hajnoczi9699bf02012-10-17 14:02:31 +02002134 qapi_free_ImageInfoList(list);
bellardea2384d2004-08-01 21:59:26 +00002135 return 0;
2136}
2137
Paolo Bonzini4c93a13b2013-09-04 19:00:33 +02002138
2139typedef struct MapEntry {
2140 int flags;
2141 int depth;
2142 int64_t start;
2143 int64_t length;
2144 int64_t offset;
2145 BlockDriverState *bs;
2146} MapEntry;
2147
2148static void dump_map_entry(OutputFormat output_format, MapEntry *e,
2149 MapEntry *next)
2150{
2151 switch (output_format) {
2152 case OFORMAT_HUMAN:
2153 if ((e->flags & BDRV_BLOCK_DATA) &&
2154 !(e->flags & BDRV_BLOCK_OFFSET_VALID)) {
2155 error_report("File contains external, encrypted or compressed clusters.");
2156 exit(1);
2157 }
2158 if ((e->flags & (BDRV_BLOCK_DATA|BDRV_BLOCK_ZERO)) == BDRV_BLOCK_DATA) {
2159 printf("%#-16"PRIx64"%#-16"PRIx64"%#-16"PRIx64"%s\n",
2160 e->start, e->length, e->offset, e->bs->filename);
2161 }
2162 /* This format ignores the distinction between 0, ZERO and ZERO|DATA.
2163 * Modify the flags here to allow more coalescing.
2164 */
2165 if (next &&
2166 (next->flags & (BDRV_BLOCK_DATA|BDRV_BLOCK_ZERO)) != BDRV_BLOCK_DATA) {
2167 next->flags &= ~BDRV_BLOCK_DATA;
2168 next->flags |= BDRV_BLOCK_ZERO;
2169 }
2170 break;
2171 case OFORMAT_JSON:
2172 printf("%s{ \"start\": %"PRId64", \"length\": %"PRId64", \"depth\": %d,"
2173 " \"zero\": %s, \"data\": %s",
2174 (e->start == 0 ? "[" : ",\n"),
2175 e->start, e->length, e->depth,
2176 (e->flags & BDRV_BLOCK_ZERO) ? "true" : "false",
2177 (e->flags & BDRV_BLOCK_DATA) ? "true" : "false");
2178 if (e->flags & BDRV_BLOCK_OFFSET_VALID) {
Paolo Bonzinic745bfb2013-09-11 18:47:52 +02002179 printf(", \"offset\": %"PRId64"", e->offset);
Paolo Bonzini4c93a13b2013-09-04 19:00:33 +02002180 }
2181 putchar('}');
2182
2183 if (!next) {
2184 printf("]\n");
2185 }
2186 break;
2187 }
2188}
2189
2190static int get_block_status(BlockDriverState *bs, int64_t sector_num,
2191 int nb_sectors, MapEntry *e)
2192{
2193 int64_t ret;
2194 int depth;
2195
2196 /* As an optimization, we could cache the current range of unallocated
2197 * clusters in each file of the chain, and avoid querying the same
2198 * range repeatedly.
2199 */
2200
2201 depth = 0;
2202 for (;;) {
2203 ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &nb_sectors);
2204 if (ret < 0) {
2205 return ret;
2206 }
2207 assert(nb_sectors);
2208 if (ret & (BDRV_BLOCK_ZERO|BDRV_BLOCK_DATA)) {
2209 break;
2210 }
Kevin Wolf760e0062015-06-17 14:55:21 +02002211 bs = backing_bs(bs);
Paolo Bonzini4c93a13b2013-09-04 19:00:33 +02002212 if (bs == NULL) {
2213 ret = 0;
2214 break;
2215 }
2216
2217 depth++;
2218 }
2219
2220 e->start = sector_num * BDRV_SECTOR_SIZE;
2221 e->length = nb_sectors * BDRV_SECTOR_SIZE;
2222 e->flags = ret & ~BDRV_BLOCK_OFFSET_MASK;
2223 e->offset = ret & BDRV_BLOCK_OFFSET_MASK;
2224 e->depth = depth;
2225 e->bs = bs;
2226 return 0;
2227}
2228
2229static int img_map(int argc, char **argv)
2230{
2231 int c;
2232 OutputFormat output_format = OFORMAT_HUMAN;
Markus Armbruster26f54e92014-10-07 13:59:04 +02002233 BlockBackend *blk;
Paolo Bonzini4c93a13b2013-09-04 19:00:33 +02002234 BlockDriverState *bs;
2235 const char *filename, *fmt, *output;
2236 int64_t length;
2237 MapEntry curr = { .length = 0 }, next;
2238 int ret = 0;
2239
2240 fmt = NULL;
2241 output = NULL;
2242 for (;;) {
2243 int option_index = 0;
2244 static const struct option long_options[] = {
2245 {"help", no_argument, 0, 'h'},
2246 {"format", required_argument, 0, 'f'},
2247 {"output", required_argument, 0, OPTION_OUTPUT},
2248 {0, 0, 0, 0}
2249 };
2250 c = getopt_long(argc, argv, "f:h",
2251 long_options, &option_index);
2252 if (c == -1) {
2253 break;
2254 }
2255 switch (c) {
2256 case '?':
2257 case 'h':
2258 help();
2259 break;
2260 case 'f':
2261 fmt = optarg;
2262 break;
2263 case OPTION_OUTPUT:
2264 output = optarg;
2265 break;
2266 }
2267 }
Fam Zhengac1307a2014-04-22 13:36:11 +08002268 if (optind != argc - 1) {
2269 error_exit("Expecting one image file name");
Paolo Bonzini4c93a13b2013-09-04 19:00:33 +02002270 }
Fam Zhengac1307a2014-04-22 13:36:11 +08002271 filename = argv[optind];
Paolo Bonzini4c93a13b2013-09-04 19:00:33 +02002272
2273 if (output && !strcmp(output, "json")) {
2274 output_format = OFORMAT_JSON;
2275 } else if (output && !strcmp(output, "human")) {
2276 output_format = OFORMAT_HUMAN;
2277 } else if (output) {
2278 error_report("--output must be used with human or json as argument.");
2279 return 1;
2280 }
2281
Markus Armbruster7e7d56d2014-10-07 13:59:05 +02002282 blk = img_open("image", filename, fmt, BDRV_O_FLAGS, true, false);
2283 if (!blk) {
2284 return 1;
Paolo Bonzini4c93a13b2013-09-04 19:00:33 +02002285 }
Markus Armbruster7e7d56d2014-10-07 13:59:05 +02002286 bs = blk_bs(blk);
Paolo Bonzini4c93a13b2013-09-04 19:00:33 +02002287
2288 if (output_format == OFORMAT_HUMAN) {
2289 printf("%-16s%-16s%-16s%s\n", "Offset", "Length", "Mapped to", "File");
2290 }
2291
Max Reitzf1d3cd72015-02-05 13:58:18 -05002292 length = blk_getlength(blk);
Paolo Bonzini4c93a13b2013-09-04 19:00:33 +02002293 while (curr.start + curr.length < length) {
2294 int64_t nsectors_left;
2295 int64_t sector_num;
2296 int n;
2297
2298 sector_num = (curr.start + curr.length) >> BDRV_SECTOR_BITS;
2299
2300 /* Probe up to 1 GiB at a time. */
2301 nsectors_left = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE) - sector_num;
2302 n = MIN(1 << (30 - BDRV_SECTOR_BITS), nsectors_left);
2303 ret = get_block_status(bs, sector_num, n, &next);
2304
2305 if (ret < 0) {
2306 error_report("Could not read file metadata: %s", strerror(-ret));
2307 goto out;
2308 }
2309
2310 if (curr.length != 0 && curr.flags == next.flags &&
2311 curr.depth == next.depth &&
2312 ((curr.flags & BDRV_BLOCK_OFFSET_VALID) == 0 ||
2313 curr.offset + curr.length == next.offset)) {
2314 curr.length += next.length;
2315 continue;
2316 }
2317
2318 if (curr.length > 0) {
2319 dump_map_entry(output_format, &curr, &next);
2320 }
2321 curr = next;
2322 }
2323
2324 dump_map_entry(output_format, &curr, NULL);
2325
2326out:
Markus Armbruster26f54e92014-10-07 13:59:04 +02002327 blk_unref(blk);
Paolo Bonzini4c93a13b2013-09-04 19:00:33 +02002328 return ret < 0;
2329}
2330
aliguorif7b4a942009-01-07 17:40:15 +00002331#define SNAPSHOT_LIST 1
2332#define SNAPSHOT_CREATE 2
2333#define SNAPSHOT_APPLY 3
2334#define SNAPSHOT_DELETE 4
2335
Stuart Brady153859b2009-06-07 00:42:17 +01002336static int img_snapshot(int argc, char **argv)
aliguorif7b4a942009-01-07 17:40:15 +00002337{
Markus Armbruster26f54e92014-10-07 13:59:04 +02002338 BlockBackend *blk;
aliguorif7b4a942009-01-07 17:40:15 +00002339 BlockDriverState *bs;
2340 QEMUSnapshotInfo sn;
2341 char *filename, *snapshot_name = NULL;
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09002342 int c, ret = 0, bdrv_oflags;
aliguorif7b4a942009-01-07 17:40:15 +00002343 int action = 0;
2344 qemu_timeval tv;
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01002345 bool quiet = false;
Wenchao Xiaa89d89d2013-09-11 14:04:33 +08002346 Error *err = NULL;
aliguorif7b4a942009-01-07 17:40:15 +00002347
Kevin Wolf710da702011-01-10 12:33:02 +01002348 bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
aliguorif7b4a942009-01-07 17:40:15 +00002349 /* Parse commandline parameters */
2350 for(;;) {
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01002351 c = getopt(argc, argv, "la:c:d:hq");
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01002352 if (c == -1) {
aliguorif7b4a942009-01-07 17:40:15 +00002353 break;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01002354 }
aliguorif7b4a942009-01-07 17:40:15 +00002355 switch(c) {
Jes Sorensenef873942010-12-06 15:25:40 +01002356 case '?':
aliguorif7b4a942009-01-07 17:40:15 +00002357 case 'h':
2358 help();
Stuart Brady153859b2009-06-07 00:42:17 +01002359 return 0;
aliguorif7b4a942009-01-07 17:40:15 +00002360 case 'l':
2361 if (action) {
Fam Zhengac1307a2014-04-22 13:36:11 +08002362 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
Stuart Brady153859b2009-06-07 00:42:17 +01002363 return 0;
aliguorif7b4a942009-01-07 17:40:15 +00002364 }
2365 action = SNAPSHOT_LIST;
Naphtali Spreif5edb012010-01-17 16:48:13 +02002366 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
aliguorif7b4a942009-01-07 17:40:15 +00002367 break;
2368 case 'a':
2369 if (action) {
Fam Zhengac1307a2014-04-22 13:36:11 +08002370 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
Stuart Brady153859b2009-06-07 00:42:17 +01002371 return 0;
aliguorif7b4a942009-01-07 17:40:15 +00002372 }
2373 action = SNAPSHOT_APPLY;
2374 snapshot_name = optarg;
2375 break;
2376 case 'c':
2377 if (action) {
Fam Zhengac1307a2014-04-22 13:36:11 +08002378 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
Stuart Brady153859b2009-06-07 00:42:17 +01002379 return 0;
aliguorif7b4a942009-01-07 17:40:15 +00002380 }
2381 action = SNAPSHOT_CREATE;
2382 snapshot_name = optarg;
2383 break;
2384 case 'd':
2385 if (action) {
Fam Zhengac1307a2014-04-22 13:36:11 +08002386 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
Stuart Brady153859b2009-06-07 00:42:17 +01002387 return 0;
aliguorif7b4a942009-01-07 17:40:15 +00002388 }
2389 action = SNAPSHOT_DELETE;
2390 snapshot_name = optarg;
2391 break;
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01002392 case 'q':
2393 quiet = true;
2394 break;
aliguorif7b4a942009-01-07 17:40:15 +00002395 }
2396 }
2397
Kevin Wolffc11eb22013-08-05 10:53:04 +02002398 if (optind != argc - 1) {
Fam Zhengac1307a2014-04-22 13:36:11 +08002399 error_exit("Expecting one image file name");
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01002400 }
aliguorif7b4a942009-01-07 17:40:15 +00002401 filename = argv[optind++];
2402
2403 /* Open the image */
Markus Armbruster7e7d56d2014-10-07 13:59:05 +02002404 blk = img_open("image", filename, NULL, bdrv_oflags, true, quiet);
2405 if (!blk) {
2406 return 1;
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09002407 }
Markus Armbruster7e7d56d2014-10-07 13:59:05 +02002408 bs = blk_bs(blk);
aliguorif7b4a942009-01-07 17:40:15 +00002409
2410 /* Perform the requested action */
2411 switch(action) {
2412 case SNAPSHOT_LIST:
2413 dump_snapshots(bs);
2414 break;
2415
2416 case SNAPSHOT_CREATE:
2417 memset(&sn, 0, sizeof(sn));
2418 pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
2419
2420 qemu_gettimeofday(&tv);
2421 sn.date_sec = tv.tv_sec;
2422 sn.date_nsec = tv.tv_usec * 1000;
2423
2424 ret = bdrv_snapshot_create(bs, &sn);
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01002425 if (ret) {
Jes Sorensen15654a62010-12-16 14:31:53 +01002426 error_report("Could not create snapshot '%s': %d (%s)",
aliguorif7b4a942009-01-07 17:40:15 +00002427 snapshot_name, ret, strerror(-ret));
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01002428 }
aliguorif7b4a942009-01-07 17:40:15 +00002429 break;
2430
2431 case SNAPSHOT_APPLY:
2432 ret = bdrv_snapshot_goto(bs, snapshot_name);
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01002433 if (ret) {
Jes Sorensen15654a62010-12-16 14:31:53 +01002434 error_report("Could not apply snapshot '%s': %d (%s)",
aliguorif7b4a942009-01-07 17:40:15 +00002435 snapshot_name, ret, strerror(-ret));
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01002436 }
aliguorif7b4a942009-01-07 17:40:15 +00002437 break;
2438
2439 case SNAPSHOT_DELETE:
Wenchao Xiaa89d89d2013-09-11 14:04:33 +08002440 bdrv_snapshot_delete_by_id_or_name(bs, snapshot_name, &err);
Markus Armbruster84d18f02014-01-30 15:07:28 +01002441 if (err) {
Wenchao Xiaa89d89d2013-09-11 14:04:33 +08002442 error_report("Could not delete snapshot '%s': (%s)",
2443 snapshot_name, error_get_pretty(err));
2444 error_free(err);
2445 ret = 1;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01002446 }
aliguorif7b4a942009-01-07 17:40:15 +00002447 break;
2448 }
2449
2450 /* Cleanup */
Markus Armbruster26f54e92014-10-07 13:59:04 +02002451 blk_unref(blk);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09002452 if (ret) {
2453 return 1;
2454 }
Stuart Brady153859b2009-06-07 00:42:17 +01002455 return 0;
aliguorif7b4a942009-01-07 17:40:15 +00002456}
2457
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002458static int img_rebase(int argc, char **argv)
2459{
Markus Armbruster26f54e92014-10-07 13:59:04 +02002460 BlockBackend *blk = NULL, *blk_old_backing = NULL, *blk_new_backing = NULL;
Max Reitzf1d3cd72015-02-05 13:58:18 -05002461 BlockDriverState *bs = NULL;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002462 char *filename;
Max Reitz40055952014-07-22 22:58:42 +02002463 const char *fmt, *cache, *src_cache, *out_basefmt, *out_baseimg;
2464 int c, flags, src_flags, ret;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002465 int unsafe = 0;
Jes Sorensen6b837bc2011-03-30 14:16:25 +02002466 int progress = 0;
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01002467 bool quiet = false;
Max Reitz34b5d2c2013-09-05 14:45:29 +02002468 Error *local_err = NULL;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002469
2470 /* Parse commandline parameters */
Kevin Wolfe53dbee2010-03-02 12:14:31 +01002471 fmt = NULL;
Federico Simoncelli661a0f72011-06-20 12:48:19 -04002472 cache = BDRV_DEFAULT_CACHE;
Max Reitz40055952014-07-22 22:58:42 +02002473 src_cache = BDRV_DEFAULT_CACHE;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002474 out_baseimg = NULL;
2475 out_basefmt = NULL;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002476 for(;;) {
Max Reitz40055952014-07-22 22:58:42 +02002477 c = getopt(argc, argv, "hf:F:b:upt:T:q");
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01002478 if (c == -1) {
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002479 break;
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01002480 }
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002481 switch(c) {
Jes Sorensenef873942010-12-06 15:25:40 +01002482 case '?':
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002483 case 'h':
2484 help();
2485 return 0;
Kevin Wolfe53dbee2010-03-02 12:14:31 +01002486 case 'f':
2487 fmt = optarg;
2488 break;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002489 case 'F':
2490 out_basefmt = optarg;
2491 break;
2492 case 'b':
2493 out_baseimg = optarg;
2494 break;
2495 case 'u':
2496 unsafe = 1;
2497 break;
Jes Sorensen6b837bc2011-03-30 14:16:25 +02002498 case 'p':
2499 progress = 1;
2500 break;
Federico Simoncelli661a0f72011-06-20 12:48:19 -04002501 case 't':
2502 cache = optarg;
2503 break;
Max Reitz40055952014-07-22 22:58:42 +02002504 case 'T':
2505 src_cache = optarg;
2506 break;
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01002507 case 'q':
2508 quiet = true;
2509 break;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002510 }
2511 }
2512
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01002513 if (quiet) {
2514 progress = 0;
2515 }
2516
Fam Zhengac1307a2014-04-22 13:36:11 +08002517 if (optind != argc - 1) {
2518 error_exit("Expecting one image file name");
2519 }
2520 if (!unsafe && !out_baseimg) {
2521 error_exit("Must specify backing file (-b) or use unsafe mode (-u)");
Jes Sorensenb8fb60d2010-12-06 15:25:39 +01002522 }
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002523 filename = argv[optind++];
2524
Jes Sorensen6b837bc2011-03-30 14:16:25 +02002525 qemu_progress_init(progress, 2.0);
2526 qemu_progress_print(0, 100);
2527
Federico Simoncelli661a0f72011-06-20 12:48:19 -04002528 flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +01002529 ret = bdrv_parse_cache_flags(cache, &flags);
Federico Simoncelli661a0f72011-06-20 12:48:19 -04002530 if (ret < 0) {
2531 error_report("Invalid cache option: %s", cache);
Stefan Hajnoczi40ed35a2014-08-26 19:17:56 +01002532 goto out;
Federico Simoncelli661a0f72011-06-20 12:48:19 -04002533 }
2534
Max Reitz40055952014-07-22 22:58:42 +02002535 src_flags = BDRV_O_FLAGS;
2536 ret = bdrv_parse_cache_flags(src_cache, &src_flags);
2537 if (ret < 0) {
2538 error_report("Invalid source cache option: %s", src_cache);
Stefan Hajnoczi40ed35a2014-08-26 19:17:56 +01002539 goto out;
Max Reitz40055952014-07-22 22:58:42 +02002540 }
2541
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002542 /*
2543 * Open the images.
2544 *
2545 * Ignore the old backing file for unsafe rebase in case we want to correct
2546 * the reference to a renamed or moved backing file.
2547 */
Markus Armbruster7e7d56d2014-10-07 13:59:05 +02002548 blk = img_open("image", filename, fmt, flags, true, quiet);
2549 if (!blk) {
Stefan Hajnoczi40ed35a2014-08-26 19:17:56 +01002550 ret = -1;
2551 goto out;
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09002552 }
Markus Armbruster7e7d56d2014-10-07 13:59:05 +02002553 bs = blk_bs(blk);
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002554
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002555 if (out_basefmt != NULL) {
Max Reitz644483d2015-02-05 13:58:17 -05002556 if (bdrv_find_format(out_basefmt) == NULL) {
Jes Sorensen15654a62010-12-16 14:31:53 +01002557 error_report("Invalid format name: '%s'", out_basefmt);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09002558 ret = -1;
2559 goto out;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002560 }
2561 }
2562
2563 /* For safe rebasing we need to compare old and new backing file */
Stefan Hajnoczi40ed35a2014-08-26 19:17:56 +01002564 if (!unsafe) {
Jeff Cody9a29e182015-01-22 08:03:30 -05002565 char backing_name[PATH_MAX];
Max Reitz644483d2015-02-05 13:58:17 -05002566 QDict *options = NULL;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002567
Max Reitz644483d2015-02-05 13:58:17 -05002568 if (bs->backing_format[0] != '\0') {
2569 options = qdict_new();
2570 qdict_put(options, "driver", qstring_from_str(bs->backing_format));
2571 }
2572
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002573 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
Max Reitz644483d2015-02-05 13:58:17 -05002574 blk_old_backing = blk_new_open("old_backing", backing_name, NULL,
2575 options, src_flags, &local_err);
2576 if (!blk_old_backing) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02002577 error_report("Could not open old backing file '%s': %s",
2578 backing_name, error_get_pretty(local_err));
2579 error_free(local_err);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09002580 goto out;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002581 }
Max Reitz644483d2015-02-05 13:58:17 -05002582
Alex Bligha6166732012-10-16 13:46:18 +01002583 if (out_baseimg[0]) {
Max Reitz644483d2015-02-05 13:58:17 -05002584 if (out_basefmt) {
2585 options = qdict_new();
2586 qdict_put(options, "driver", qstring_from_str(out_basefmt));
2587 } else {
2588 options = NULL;
2589 }
2590
2591 blk_new_backing = blk_new_open("new_backing", out_baseimg, NULL,
2592 options, src_flags, &local_err);
2593 if (!blk_new_backing) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02002594 error_report("Could not open new backing file '%s': %s",
2595 out_baseimg, error_get_pretty(local_err));
2596 error_free(local_err);
Alex Bligha6166732012-10-16 13:46:18 +01002597 goto out;
2598 }
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002599 }
2600 }
2601
2602 /*
2603 * Check each unallocated cluster in the COW file. If it is unallocated,
2604 * accesses go to the backing file. We must therefore compare this cluster
2605 * in the old and new backing file, and if they differ we need to copy it
2606 * from the old backing file into the COW file.
2607 *
2608 * If qemu-img crashes during this step, no harm is done. The content of
2609 * the image is the same as the original one at any time.
2610 */
2611 if (!unsafe) {
Markus Armbruster52bf1e72014-06-26 13:23:25 +02002612 int64_t num_sectors;
2613 int64_t old_backing_num_sectors;
2614 int64_t new_backing_num_sectors = 0;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002615 uint64_t sector;
Kevin Wolfcc60e322010-04-29 14:47:48 +02002616 int n;
TeLeMand6771bf2010-02-08 16:20:00 +08002617 uint8_t * buf_old;
2618 uint8_t * buf_new;
Kevin Wolf1f710492012-10-12 14:29:18 +02002619 float local_progress = 0;
TeLeMand6771bf2010-02-08 16:20:00 +08002620
Max Reitzf1d3cd72015-02-05 13:58:18 -05002621 buf_old = blk_blockalign(blk, IO_BUF_SIZE);
2622 buf_new = blk_blockalign(blk, IO_BUF_SIZE);
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002623
Max Reitzf1d3cd72015-02-05 13:58:18 -05002624 num_sectors = blk_nb_sectors(blk);
Markus Armbruster52bf1e72014-06-26 13:23:25 +02002625 if (num_sectors < 0) {
2626 error_report("Could not get size of '%s': %s",
2627 filename, strerror(-num_sectors));
2628 ret = -1;
2629 goto out;
2630 }
Max Reitzf1d3cd72015-02-05 13:58:18 -05002631 old_backing_num_sectors = blk_nb_sectors(blk_old_backing);
Markus Armbruster52bf1e72014-06-26 13:23:25 +02002632 if (old_backing_num_sectors < 0) {
Jeff Cody9a29e182015-01-22 08:03:30 -05002633 char backing_name[PATH_MAX];
Markus Armbruster52bf1e72014-06-26 13:23:25 +02002634
2635 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
2636 error_report("Could not get size of '%s': %s",
2637 backing_name, strerror(-old_backing_num_sectors));
2638 ret = -1;
2639 goto out;
2640 }
Max Reitzf1d3cd72015-02-05 13:58:18 -05002641 if (blk_new_backing) {
2642 new_backing_num_sectors = blk_nb_sectors(blk_new_backing);
Markus Armbruster52bf1e72014-06-26 13:23:25 +02002643 if (new_backing_num_sectors < 0) {
2644 error_report("Could not get size of '%s': %s",
2645 out_baseimg, strerror(-new_backing_num_sectors));
2646 ret = -1;
2647 goto out;
2648 }
Alex Bligha6166732012-10-16 13:46:18 +01002649 }
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002650
Kevin Wolf1f710492012-10-12 14:29:18 +02002651 if (num_sectors != 0) {
2652 local_progress = (float)100 /
2653 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
2654 }
2655
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002656 for (sector = 0; sector < num_sectors; sector += n) {
2657
2658 /* How many sectors can we handle with the next read? */
2659 if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
2660 n = (IO_BUF_SIZE / 512);
2661 } else {
2662 n = num_sectors - sector;
2663 }
2664
2665 /* If the cluster is allocated, we don't need to take action */
Kevin Wolfcc60e322010-04-29 14:47:48 +02002666 ret = bdrv_is_allocated(bs, sector, n, &n);
Paolo Bonzinid6636402013-09-04 19:00:25 +02002667 if (ret < 0) {
2668 error_report("error while reading image metadata: %s",
2669 strerror(-ret));
2670 goto out;
2671 }
Kevin Wolfcc60e322010-04-29 14:47:48 +02002672 if (ret) {
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002673 continue;
2674 }
2675
Kevin Wolf87a1b3e2011-12-07 12:42:10 +01002676 /*
2677 * Read old and new backing file and take into consideration that
2678 * backing files may be smaller than the COW image.
2679 */
2680 if (sector >= old_backing_num_sectors) {
2681 memset(buf_old, 0, n * BDRV_SECTOR_SIZE);
2682 } else {
2683 if (sector + n > old_backing_num_sectors) {
2684 n = old_backing_num_sectors - sector;
2685 }
2686
Max Reitzf1d3cd72015-02-05 13:58:18 -05002687 ret = blk_read(blk_old_backing, sector, buf_old, n);
Kevin Wolf87a1b3e2011-12-07 12:42:10 +01002688 if (ret < 0) {
2689 error_report("error while reading from old backing file");
2690 goto out;
2691 }
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002692 }
Kevin Wolf87a1b3e2011-12-07 12:42:10 +01002693
Max Reitzf1d3cd72015-02-05 13:58:18 -05002694 if (sector >= new_backing_num_sectors || !blk_new_backing) {
Kevin Wolf87a1b3e2011-12-07 12:42:10 +01002695 memset(buf_new, 0, n * BDRV_SECTOR_SIZE);
2696 } else {
2697 if (sector + n > new_backing_num_sectors) {
2698 n = new_backing_num_sectors - sector;
2699 }
2700
Max Reitzf1d3cd72015-02-05 13:58:18 -05002701 ret = blk_read(blk_new_backing, sector, buf_new, n);
Kevin Wolf87a1b3e2011-12-07 12:42:10 +01002702 if (ret < 0) {
2703 error_report("error while reading from new backing file");
2704 goto out;
2705 }
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002706 }
2707
2708 /* If they differ, we need to write to the COW file */
2709 uint64_t written = 0;
2710
2711 while (written < n) {
2712 int pnum;
2713
2714 if (compare_sectors(buf_old + written * 512,
Kevin Wolf60b1bd42010-02-17 12:32:59 +01002715 buf_new + written * 512, n - written, &pnum))
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002716 {
Max Reitzf1d3cd72015-02-05 13:58:18 -05002717 ret = blk_write(blk, sector + written,
2718 buf_old + written * 512, pnum);
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002719 if (ret < 0) {
Jes Sorensen15654a62010-12-16 14:31:53 +01002720 error_report("Error while writing to COW image: %s",
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002721 strerror(-ret));
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09002722 goto out;
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002723 }
2724 }
2725
2726 written += pnum;
2727 }
Jes Sorensen6b837bc2011-03-30 14:16:25 +02002728 qemu_progress_print(local_progress, 100);
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002729 }
TeLeMand6771bf2010-02-08 16:20:00 +08002730
Kevin Wolfbb1c0592011-08-08 14:09:12 +02002731 qemu_vfree(buf_old);
2732 qemu_vfree(buf_new);
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002733 }
2734
2735 /*
2736 * Change the backing file. All clusters that are different from the old
2737 * backing file are overwritten in the COW file now, so the visible content
2738 * doesn't change when we switch the backing file.
2739 */
Alex Bligha6166732012-10-16 13:46:18 +01002740 if (out_baseimg && *out_baseimg) {
2741 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
2742 } else {
2743 ret = bdrv_change_backing_file(bs, NULL, NULL);
2744 }
2745
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002746 if (ret == -ENOSPC) {
Jes Sorensen15654a62010-12-16 14:31:53 +01002747 error_report("Could not change the backing file to '%s': No "
2748 "space left in the file header", out_baseimg);
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002749 } else if (ret < 0) {
Jes Sorensen15654a62010-12-16 14:31:53 +01002750 error_report("Could not change the backing file to '%s': %s",
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002751 out_baseimg, strerror(-ret));
2752 }
2753
Jes Sorensen6b837bc2011-03-30 14:16:25 +02002754 qemu_progress_print(100, 0);
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002755 /*
2756 * TODO At this point it is possible to check if any clusters that are
2757 * allocated in the COW file are the same in the backing file. If so, they
2758 * could be dropped from the COW file. Don't do this before switching the
2759 * backing file, in case of a crash this would lead to corruption.
2760 */
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09002761out:
Jes Sorensen6b837bc2011-03-30 14:16:25 +02002762 qemu_progress_end();
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002763 /* Cleanup */
2764 if (!unsafe) {
Markus Armbruster26f54e92014-10-07 13:59:04 +02002765 blk_unref(blk_old_backing);
Markus Armbruster26f54e92014-10-07 13:59:04 +02002766 blk_unref(blk_new_backing);
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002767 }
2768
Markus Armbruster26f54e92014-10-07 13:59:04 +02002769 blk_unref(blk);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09002770 if (ret) {
2771 return 1;
2772 }
Kevin Wolf3e85c6f2010-01-12 12:55:18 +01002773 return 0;
2774}
2775
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01002776static int img_resize(int argc, char **argv)
2777{
Markus Armbruster6750e792015-02-12 17:43:08 +01002778 Error *err = NULL;
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01002779 int c, ret, relative;
2780 const char *filename, *fmt, *size;
2781 int64_t n, total_size;
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01002782 bool quiet = false;
Markus Armbruster26f54e92014-10-07 13:59:04 +02002783 BlockBackend *blk = NULL;
Dong Xu Wang20caf0f2012-08-06 10:18:42 +08002784 QemuOpts *param;
2785 static QemuOptsList resize_options = {
2786 .name = "resize_options",
2787 .head = QTAILQ_HEAD_INITIALIZER(resize_options.head),
2788 .desc = {
2789 {
2790 .name = BLOCK_OPT_SIZE,
2791 .type = QEMU_OPT_SIZE,
2792 .help = "Virtual disk size"
2793 }, {
2794 /* end of list */
2795 }
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01002796 },
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01002797 };
2798
Kevin Wolfe80fec72011-04-29 10:58:12 +02002799 /* Remove size from argv manually so that negative numbers are not treated
2800 * as options by getopt. */
2801 if (argc < 3) {
Fam Zhengac1307a2014-04-22 13:36:11 +08002802 error_exit("Not enough arguments");
Kevin Wolfe80fec72011-04-29 10:58:12 +02002803 return 1;
2804 }
2805
2806 size = argv[--argc];
2807
2808 /* Parse getopt arguments */
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01002809 fmt = NULL;
2810 for(;;) {
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01002811 c = getopt(argc, argv, "f:hq");
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01002812 if (c == -1) {
2813 break;
2814 }
2815 switch(c) {
Jes Sorensenef873942010-12-06 15:25:40 +01002816 case '?':
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01002817 case 'h':
2818 help();
2819 break;
2820 case 'f':
2821 fmt = optarg;
2822 break;
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01002823 case 'q':
2824 quiet = true;
2825 break;
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01002826 }
2827 }
Kevin Wolffc11eb22013-08-05 10:53:04 +02002828 if (optind != argc - 1) {
Fam Zhengac1307a2014-04-22 13:36:11 +08002829 error_exit("Expecting one image file name");
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01002830 }
2831 filename = argv[optind++];
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01002832
2833 /* Choose grow, shrink, or absolute resize mode */
2834 switch (size[0]) {
2835 case '+':
2836 relative = 1;
2837 size++;
2838 break;
2839 case '-':
2840 relative = -1;
2841 size++;
2842 break;
2843 default:
2844 relative = 0;
2845 break;
2846 }
2847
2848 /* Parse size */
Peter Crosthwaite87ea75d2014-01-01 18:49:17 -08002849 param = qemu_opts_create(&resize_options, NULL, 0, &error_abort);
Markus Armbrusterf43e47d2015-02-12 17:52:20 +01002850 qemu_opt_set(param, BLOCK_OPT_SIZE, size, &err);
Markus Armbruster6750e792015-02-12 17:43:08 +01002851 if (err) {
2852 error_report_err(err);
Jes Sorensen2a819982010-12-06 17:08:31 +01002853 ret = -1;
Dong Xu Wang20caf0f2012-08-06 10:18:42 +08002854 qemu_opts_del(param);
Jes Sorensen2a819982010-12-06 17:08:31 +01002855 goto out;
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01002856 }
Dong Xu Wang20caf0f2012-08-06 10:18:42 +08002857 n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
2858 qemu_opts_del(param);
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01002859
Markus Armbruster7e7d56d2014-10-07 13:59:05 +02002860 blk = img_open("image", filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR,
2861 true, quiet);
2862 if (!blk) {
Jes Sorensen2a819982010-12-06 17:08:31 +01002863 ret = -1;
2864 goto out;
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09002865 }
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01002866
2867 if (relative) {
Max Reitzf1d3cd72015-02-05 13:58:18 -05002868 total_size = blk_getlength(blk) + n * relative;
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01002869 } else {
2870 total_size = n;
2871 }
2872 if (total_size <= 0) {
Jes Sorensen15654a62010-12-16 14:31:53 +01002873 error_report("New image size must be positive");
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09002874 ret = -1;
2875 goto out;
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01002876 }
2877
Max Reitzf1d3cd72015-02-05 13:58:18 -05002878 ret = blk_truncate(blk, total_size);
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01002879 switch (ret) {
2880 case 0:
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01002881 qprintf(quiet, "Image resized.\n");
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01002882 break;
2883 case -ENOTSUP:
Kevin Wolf259b2172012-03-06 12:44:45 +01002884 error_report("This image does not support resize");
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01002885 break;
2886 case -EACCES:
Jes Sorensen15654a62010-12-16 14:31:53 +01002887 error_report("Image is read-only");
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01002888 break;
2889 default:
Jes Sorensen15654a62010-12-16 14:31:53 +01002890 error_report("Error resizing image (%d)", -ret);
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01002891 break;
2892 }
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09002893out:
Markus Armbruster26f54e92014-10-07 13:59:04 +02002894 blk_unref(blk);
MORITA Kazutakac2abcce2010-06-21 04:26:35 +09002895 if (ret) {
2896 return 1;
2897 }
Stefan Hajnocziae6b0ed2010-04-24 09:12:12 +01002898 return 0;
2899}
2900
Max Reitz76a3a342014-10-27 11:12:51 +01002901static void amend_status_cb(BlockDriverState *bs,
2902 int64_t offset, int64_t total_work_size)
2903{
2904 qemu_progress_print(100.f * offset / total_work_size, 0);
2905}
2906
Max Reitz6f176b42013-09-03 10:09:50 +02002907static int img_amend(int argc, char **argv)
2908{
Markus Armbrusterdc523cd342015-02-12 18:37:11 +01002909 Error *err = NULL;
Max Reitz6f176b42013-09-03 10:09:50 +02002910 int c, ret = 0;
2911 char *options = NULL;
Chunyan Liu83d05212014-06-05 17:20:51 +08002912 QemuOptsList *create_opts = NULL;
2913 QemuOpts *opts = NULL;
Max Reitzbd39e6e2014-07-22 22:58:43 +02002914 const char *fmt = NULL, *filename, *cache;
2915 int flags;
Max Reitz76a3a342014-10-27 11:12:51 +01002916 bool quiet = false, progress = false;
Markus Armbruster26f54e92014-10-07 13:59:04 +02002917 BlockBackend *blk = NULL;
Max Reitz6f176b42013-09-03 10:09:50 +02002918 BlockDriverState *bs = NULL;
2919
Max Reitzbd39e6e2014-07-22 22:58:43 +02002920 cache = BDRV_DEFAULT_CACHE;
Max Reitz6f176b42013-09-03 10:09:50 +02002921 for (;;) {
Max Reitz76a3a342014-10-27 11:12:51 +01002922 c = getopt(argc, argv, "ho:f:t:pq");
Max Reitz6f176b42013-09-03 10:09:50 +02002923 if (c == -1) {
2924 break;
2925 }
2926
2927 switch (c) {
2928 case 'h':
2929 case '?':
2930 help();
2931 break;
2932 case 'o':
Kevin Wolf626f84f2014-02-21 16:24:06 +01002933 if (!is_valid_option_list(optarg)) {
2934 error_report("Invalid option list: %s", optarg);
2935 ret = -1;
Max Reitze814dff2015-08-20 16:00:38 -07002936 goto out_no_progress;
Kevin Wolf626f84f2014-02-21 16:24:06 +01002937 }
2938 if (!options) {
2939 options = g_strdup(optarg);
2940 } else {
2941 char *old_options = options;
2942 options = g_strdup_printf("%s,%s", options, optarg);
2943 g_free(old_options);
2944 }
Max Reitz6f176b42013-09-03 10:09:50 +02002945 break;
2946 case 'f':
2947 fmt = optarg;
2948 break;
Max Reitzbd39e6e2014-07-22 22:58:43 +02002949 case 't':
2950 cache = optarg;
2951 break;
Max Reitz76a3a342014-10-27 11:12:51 +01002952 case 'p':
2953 progress = true;
2954 break;
Max Reitz6f176b42013-09-03 10:09:50 +02002955 case 'q':
2956 quiet = true;
2957 break;
2958 }
2959 }
2960
Max Reitz6f176b42013-09-03 10:09:50 +02002961 if (!options) {
Fam Zhengac1307a2014-04-22 13:36:11 +08002962 error_exit("Must specify options (-o)");
Max Reitz6f176b42013-09-03 10:09:50 +02002963 }
2964
Max Reitz76a3a342014-10-27 11:12:51 +01002965 if (quiet) {
2966 progress = false;
2967 }
2968 qemu_progress_init(progress, 1.0);
2969
Kevin Wolfa283cb62014-02-21 16:24:07 +01002970 filename = (optind == argc - 1) ? argv[argc - 1] : NULL;
2971 if (fmt && has_help_option(options)) {
2972 /* If a format is explicitly specified (and possibly no filename is
2973 * given), print option help here */
2974 ret = print_block_option_help(filename, fmt);
2975 goto out;
2976 }
2977
2978 if (optind != argc - 1) {
Max Reitzb2f27e42014-10-27 11:12:52 +01002979 error_report("Expecting one image file name");
2980 ret = -1;
2981 goto out;
Kevin Wolfa283cb62014-02-21 16:24:07 +01002982 }
Max Reitz6f176b42013-09-03 10:09:50 +02002983
Max Reitzbd39e6e2014-07-22 22:58:43 +02002984 flags = BDRV_O_FLAGS | BDRV_O_RDWR;
2985 ret = bdrv_parse_cache_flags(cache, &flags);
2986 if (ret < 0) {
2987 error_report("Invalid cache option: %s", cache);
2988 goto out;
2989 }
2990
Markus Armbruster7e7d56d2014-10-07 13:59:05 +02002991 blk = img_open("image", filename, fmt, flags, true, quiet);
2992 if (!blk) {
Max Reitz6f176b42013-09-03 10:09:50 +02002993 ret = -1;
2994 goto out;
2995 }
Markus Armbruster7e7d56d2014-10-07 13:59:05 +02002996 bs = blk_bs(blk);
Max Reitz6f176b42013-09-03 10:09:50 +02002997
2998 fmt = bs->drv->format_name;
2999
Kevin Wolf626f84f2014-02-21 16:24:06 +01003000 if (has_help_option(options)) {
Kevin Wolfa283cb62014-02-21 16:24:07 +01003001 /* If the format was auto-detected, print option help here */
Max Reitz6f176b42013-09-03 10:09:50 +02003002 ret = print_block_option_help(filename, fmt);
3003 goto out;
3004 }
3005
Max Reitzb2439d22014-12-02 18:32:47 +01003006 if (!bs->drv->create_opts) {
3007 error_report("Format driver '%s' does not support any options to amend",
3008 fmt);
3009 ret = -1;
3010 goto out;
3011 }
3012
Chunyan Liuc282e1f2014-06-05 17:21:11 +08003013 create_opts = qemu_opts_append(create_opts, bs->drv->create_opts);
Chunyan Liu83d05212014-06-05 17:20:51 +08003014 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
Markus Armbrusterdc523cd342015-02-12 18:37:11 +01003015 if (options) {
3016 qemu_opts_do_parse(opts, options, NULL, &err);
3017 if (err) {
Markus Armbruster97a2ca72015-03-14 10:23:15 +01003018 error_report_err(err);
Markus Armbrusterdc523cd342015-02-12 18:37:11 +01003019 ret = -1;
3020 goto out;
3021 }
Max Reitz6f176b42013-09-03 10:09:50 +02003022 }
3023
Max Reitz76a3a342014-10-27 11:12:51 +01003024 /* In case the driver does not call amend_status_cb() */
3025 qemu_progress_print(0.f, 0);
3026 ret = bdrv_amend_options(bs, opts, &amend_status_cb);
3027 qemu_progress_print(100.f, 0);
Max Reitz6f176b42013-09-03 10:09:50 +02003028 if (ret < 0) {
3029 error_report("Error while amending options: %s", strerror(-ret));
3030 goto out;
3031 }
3032
3033out:
Max Reitz76a3a342014-10-27 11:12:51 +01003034 qemu_progress_end();
3035
Max Reitze814dff2015-08-20 16:00:38 -07003036out_no_progress:
Markus Armbruster26f54e92014-10-07 13:59:04 +02003037 blk_unref(blk);
Chunyan Liu83d05212014-06-05 17:20:51 +08003038 qemu_opts_del(opts);
3039 qemu_opts_free(create_opts);
Kevin Wolf626f84f2014-02-21 16:24:06 +01003040 g_free(options);
3041
Max Reitz6f176b42013-09-03 10:09:50 +02003042 if (ret) {
3043 return 1;
3044 }
3045 return 0;
3046}
3047
Anthony Liguoric227f092009-10-01 16:12:16 -05003048static const img_cmd_t img_cmds[] = {
Stuart Brady153859b2009-06-07 00:42:17 +01003049#define DEF(option, callback, arg_string) \
3050 { option, callback },
3051#include "qemu-img-cmds.h"
3052#undef DEF
3053#undef GEN_DOCS
3054 { NULL, NULL, },
3055};
3056
bellardea2384d2004-08-01 21:59:26 +00003057int main(int argc, char **argv)
3058{
Anthony Liguoric227f092009-10-01 16:12:16 -05003059 const img_cmd_t *cmd;
Stuart Brady153859b2009-06-07 00:42:17 +01003060 const char *cmdname;
Chrysostomos Nanakos2f78e492014-09-18 14:30:49 +03003061 Error *local_error = NULL;
Jeff Cody7db16892014-04-25 17:02:32 -04003062 int c;
Jeff Cody7db16892014-04-25 17:02:32 -04003063 static const struct option long_options[] = {
3064 {"help", no_argument, 0, 'h'},
Jeff Cody5f6979c2014-04-28 14:37:18 -04003065 {"version", no_argument, 0, 'v'},
Jeff Cody7db16892014-04-25 17:02:32 -04003066 {0, 0, 0, 0}
3067 };
bellardea2384d2004-08-01 21:59:26 +00003068
MORITA Kazutaka526eda12013-07-23 17:30:11 +09003069#ifdef CONFIG_POSIX
3070 signal(SIGPIPE, SIG_IGN);
3071#endif
3072
Kevin Wolf53f76e52010-12-16 15:10:32 +01003073 error_set_progname(argv[0]);
Fam Zheng10f5bff2014-02-10 14:48:51 +08003074 qemu_init_exec_dir(argv[0]);
Kevin Wolf53f76e52010-12-16 15:10:32 +01003075
Chrysostomos Nanakos2f78e492014-09-18 14:30:49 +03003076 if (qemu_init_main_loop(&local_error)) {
Markus Armbruster565f65d2015-02-12 13:55:05 +01003077 error_report_err(local_error);
Chrysostomos Nanakos2f78e492014-09-18 14:30:49 +03003078 exit(EXIT_FAILURE);
3079 }
3080
bellardea2384d2004-08-01 21:59:26 +00003081 bdrv_init();
Fam Zhengac1307a2014-04-22 13:36:11 +08003082 if (argc < 2) {
3083 error_exit("Not enough arguments");
3084 }
Stuart Brady153859b2009-06-07 00:42:17 +01003085 cmdname = argv[1];
Stuart Brady153859b2009-06-07 00:42:17 +01003086
3087 /* find the command */
Jeff Cody5f6979c2014-04-28 14:37:18 -04003088 for (cmd = img_cmds; cmd->name != NULL; cmd++) {
Stuart Brady153859b2009-06-07 00:42:17 +01003089 if (!strcmp(cmdname, cmd->name)) {
Jeff Cody7db16892014-04-25 17:02:32 -04003090 return cmd->handler(argc - 1, argv + 1);
Stuart Brady153859b2009-06-07 00:42:17 +01003091 }
bellardea2384d2004-08-01 21:59:26 +00003092 }
Stuart Brady153859b2009-06-07 00:42:17 +01003093
Jeff Cody5f6979c2014-04-28 14:37:18 -04003094 c = getopt_long(argc, argv, "h", long_options, NULL);
Jeff Cody7db16892014-04-25 17:02:32 -04003095
3096 if (c == 'h') {
3097 help();
3098 }
Jeff Cody5f6979c2014-04-28 14:37:18 -04003099 if (c == 'v') {
3100 printf(QEMU_IMG_VERSION);
3101 return 0;
3102 }
Jeff Cody7db16892014-04-25 17:02:32 -04003103
Stuart Brady153859b2009-06-07 00:42:17 +01003104 /* not found */
Fam Zhengac1307a2014-04-22 13:36:11 +08003105 error_exit("Command not found: %s", cmdname);
bellardea2384d2004-08-01 21:59:26 +00003106}