blob: 9569deeaf0f1c03cae34649f1fd8fb63fd6323b8 [file] [log] [blame]
bellardea2384d2004-08-01 21:59:26 +00001/*
2 * Block driver for the QCOW format
ths5fafdf22007-09-16 21:08:06 +00003 *
bellard83f64092006-08-01 16:21:11 +00004 * Copyright (c) 2004-2006 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 */
Peter Maydell80c71a22016-01-18 18:01:42 +000024#include "qemu/osdep.h"
Markus Armbrusterda34e652016-03-14 09:01:28 +010025#include "qapi/error.h"
pbrookfaf07962007-11-11 02:51:17 +000026#include "qemu-common.h"
Daniel P. Berrangee6ff69b2016-03-21 14:11:48 +000027#include "qemu/error-report.h"
Paolo Bonzini737e1502012-12-17 18:19:44 +010028#include "block/block_int.h"
Kevin Wolf6af40162016-03-08 15:57:05 +010029#include "sysemu/block-backend.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010030#include "qemu/module.h"
Paolo Bonzini58369e22016-03-15 17:22:36 +010031#include "qemu/bswap.h"
bellard28d34b82004-09-29 21:30:43 +000032#include <zlib.h>
Markus Armbrustercc7a8ea2015-03-17 17:22:46 +010033#include "qapi/qmp/qerror.h"
Daniel P. Berranged85f4222017-06-23 17:24:08 +010034#include "qapi/qmp/qstring.h"
35#include "crypto/block.h"
Juan Quintela795c40b2017-04-06 12:00:28 +020036#include "migration/blocker.h"
Daniel P. Berranged85f4222017-06-23 17:24:08 +010037#include "block/crypto.h"
bellardea2384d2004-08-01 21:59:26 +000038
39/**************************************************************/
40/* QEMU COW block driver with compression and encryption support */
41
42#define QCOW_MAGIC (('Q' << 24) | ('F' << 16) | ('I' << 8) | 0xfb)
43#define QCOW_VERSION 1
44
45#define QCOW_CRYPT_NONE 0
46#define QCOW_CRYPT_AES 1
47
48#define QCOW_OFLAG_COMPRESSED (1LL << 63)
49
50typedef struct QCowHeader {
51 uint32_t magic;
52 uint32_t version;
53 uint64_t backing_file_offset;
54 uint32_t backing_file_size;
55 uint32_t mtime;
56 uint64_t size; /* in bytes */
57 uint8_t cluster_bits;
58 uint8_t l2_bits;
Kevin Wolfea54fef2014-05-07 16:56:10 +020059 uint16_t padding;
bellardea2384d2004-08-01 21:59:26 +000060 uint32_t crypt_method;
61 uint64_t l1_table_offset;
Kevin Wolfea54fef2014-05-07 16:56:10 +020062} QEMU_PACKED QCowHeader;
bellardea2384d2004-08-01 21:59:26 +000063
64#define L2_CACHE_SIZE 16
65
66typedef struct BDRVQcowState {
bellardea2384d2004-08-01 21:59:26 +000067 int cluster_bits;
68 int cluster_size;
69 int cluster_sectors;
70 int l2_bits;
71 int l2_size;
Kevin Wolf46485de2014-05-08 13:08:20 +020072 unsigned int l1_size;
bellardea2384d2004-08-01 21:59:26 +000073 uint64_t cluster_offset_mask;
74 uint64_t l1_table_offset;
75 uint64_t *l1_table;
76 uint64_t *l2_cache;
77 uint64_t l2_cache_offsets[L2_CACHE_SIZE];
78 uint32_t l2_cache_counts[L2_CACHE_SIZE];
79 uint8_t *cluster_cache;
80 uint8_t *cluster_data;
81 uint64_t cluster_cache_offset;
Daniel P. Berranged85f4222017-06-23 17:24:08 +010082 QCryptoBlock *crypto; /* Disk encryption format driver */
bellardea2384d2004-08-01 21:59:26 +000083 uint32_t crypt_method_header;
Kevin Wolf52b8eb62011-07-15 16:27:42 +020084 CoMutex lock;
Kevin Wolffd9f1022011-11-22 16:44:45 +010085 Error *migration_blocker;
bellardea2384d2004-08-01 21:59:26 +000086} BDRVQcowState;
87
Kevin Wolf66f82ce2010-04-14 14:17:38 +020088static int decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset);
bellardea2384d2004-08-01 21:59:26 +000089
90static int qcow_probe(const uint8_t *buf, int buf_size, const char *filename)
91{
92 const QCowHeader *cow_header = (const void *)buf;
ths3b46e622007-09-17 08:09:54 +000093
bellard712e7872005-04-28 21:09:32 +000094 if (buf_size >= sizeof(QCowHeader) &&
95 be32_to_cpu(cow_header->magic) == QCOW_MAGIC &&
ths5fafdf22007-09-16 21:08:06 +000096 be32_to_cpu(cow_header->version) == QCOW_VERSION)
bellardea2384d2004-08-01 21:59:26 +000097 return 100;
98 else
99 return 0;
100}
101
Daniel P. Berranged85f4222017-06-23 17:24:08 +0100102static QemuOptsList qcow_runtime_opts = {
103 .name = "qcow",
104 .head = QTAILQ_HEAD_INITIALIZER(qcow_runtime_opts.head),
105 .desc = {
106 BLOCK_CRYPTO_OPT_DEF_QCOW_KEY_SECRET("encrypt."),
107 { /* end of list */ }
108 },
109};
110
Max Reitz015a1032013-09-05 14:22:29 +0200111static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
112 Error **errp)
bellardea2384d2004-08-01 21:59:26 +0000113{
114 BDRVQcowState *s = bs->opaque;
Kevin Wolfd66e5ce2014-05-08 13:35:09 +0200115 unsigned int len, i, shift;
116 int ret;
bellardea2384d2004-08-01 21:59:26 +0000117 QCowHeader header;
Ashijeet Acharyafe44dc92017-01-16 17:01:53 +0530118 Error *local_err = NULL;
Daniel P. Berranged85f4222017-06-23 17:24:08 +0100119 QCryptoBlockOpenOptions *crypto_opts = NULL;
120 unsigned int cflags = 0;
121 QDict *encryptopts = NULL;
122 const char *encryptfmt;
123
124 qdict_extract_subqdict(options, &encryptopts, "encrypt.");
125 encryptfmt = qdict_get_try_str(encryptopts, "format");
bellard83f64092006-08-01 16:21:11 +0000126
Kevin Wolf4e4bf5c2016-12-16 18:52:37 +0100127 bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
128 false, errp);
129 if (!bs->file) {
Daniel P. Berranged85f4222017-06-23 17:24:08 +0100130 ret = -EINVAL;
131 goto fail;
Kevin Wolf4e4bf5c2016-12-16 18:52:37 +0100132 }
133
Kevin Wolfcf2ab8f2016-06-20 18:24:02 +0200134 ret = bdrv_pread(bs->file, 0, &header, sizeof(header));
Li Zhi Hui84b0ec02011-12-15 18:14:00 +0800135 if (ret < 0) {
bellardea2384d2004-08-01 21:59:26 +0000136 goto fail;
Li Zhi Hui84b0ec02011-12-15 18:14:00 +0800137 }
bellardea2384d2004-08-01 21:59:26 +0000138 be32_to_cpus(&header.magic);
139 be32_to_cpus(&header.version);
140 be64_to_cpus(&header.backing_file_offset);
141 be32_to_cpus(&header.backing_file_size);
142 be32_to_cpus(&header.mtime);
143 be64_to_cpus(&header.size);
144 be32_to_cpus(&header.crypt_method);
145 be64_to_cpus(&header.l1_table_offset);
ths3b46e622007-09-17 08:09:54 +0000146
Li Zhi Hui84b0ec02011-12-15 18:14:00 +0800147 if (header.magic != QCOW_MAGIC) {
Paolo Bonzini76abe402014-02-17 14:44:06 +0100148 error_setg(errp, "Image not in qcow format");
149 ret = -EINVAL;
bellardea2384d2004-08-01 21:59:26 +0000150 goto fail;
Li Zhi Hui84b0ec02011-12-15 18:14:00 +0800151 }
152 if (header.version != QCOW_VERSION) {
Max Reitza55448b2016-03-16 19:54:33 +0100153 error_setg(errp, "Unsupported qcow version %" PRIu32, header.version);
Li Zhi Hui84b0ec02011-12-15 18:14:00 +0800154 ret = -ENOTSUP;
bellardea2384d2004-08-01 21:59:26 +0000155 goto fail;
Li Zhi Hui84b0ec02011-12-15 18:14:00 +0800156 }
157
Kevin Wolf7159a452014-05-07 17:30:30 +0200158 if (header.size <= 1) {
159 error_setg(errp, "Image size is too small (must be at least 2 bytes)");
Li Zhi Hui84b0ec02011-12-15 18:14:00 +0800160 ret = -EINVAL;
bellardea2384d2004-08-01 21:59:26 +0000161 goto fail;
Li Zhi Hui84b0ec02011-12-15 18:14:00 +0800162 }
Kevin Wolf7159a452014-05-07 17:30:30 +0200163 if (header.cluster_bits < 9 || header.cluster_bits > 16) {
164 error_setg(errp, "Cluster size must be between 512 and 64k");
165 ret = -EINVAL;
166 goto fail;
167 }
168
Kevin Wolf42eb5812014-05-15 16:10:11 +0200169 /* l2_bits specifies number of entries; storing a uint64_t in each entry,
170 * so bytes = num_entries << 3. */
171 if (header.l2_bits < 9 - 3 || header.l2_bits > 16 - 3) {
172 error_setg(errp, "L2 table size must be between 512 and 64k");
173 ret = -EINVAL;
174 goto fail;
175 }
176
bellardea2384d2004-08-01 21:59:26 +0000177 s->crypt_method_header = header.crypt_method;
Li Zhi Hui84b0ec02011-12-15 18:14:00 +0800178 if (s->crypt_method_header) {
Daniel P. Berrangee6ff69b2016-03-21 14:11:48 +0000179 if (bdrv_uses_whitelist() &&
180 s->crypt_method_header == QCOW_CRYPT_AES) {
Daniel P. Berrange8c0dcbc2016-06-13 12:30:09 +0100181 error_setg(errp,
182 "Use of AES-CBC encrypted qcow images is no longer "
183 "supported in system emulators");
184 error_append_hint(errp,
185 "You can use 'qemu-img convert' to convert your "
186 "image to an alternative supported format, such "
187 "as unencrypted qcow, or raw with the LUKS "
188 "format instead.\n");
189 ret = -ENOSYS;
190 goto fail;
Daniel P. Berrangee6ff69b2016-03-21 14:11:48 +0000191 }
Daniel P. Berranged85f4222017-06-23 17:24:08 +0100192 if (s->crypt_method_header == QCOW_CRYPT_AES) {
193 if (encryptfmt && !g_str_equal(encryptfmt, "aes")) {
194 error_setg(errp,
195 "Header reported 'aes' encryption format but "
196 "options specify '%s'", encryptfmt);
197 ret = -EINVAL;
198 goto fail;
199 }
200 qdict_del(encryptopts, "format");
201 crypto_opts = block_crypto_open_opts_init(
202 Q_CRYPTO_BLOCK_FORMAT_QCOW, encryptopts, errp);
203 if (!crypto_opts) {
204 ret = -EINVAL;
205 goto fail;
206 }
Daniel P. Berrangee6ff69b2016-03-21 14:11:48 +0000207
Daniel P. Berranged85f4222017-06-23 17:24:08 +0100208 if (flags & BDRV_O_NO_IO) {
209 cflags |= QCRYPTO_BLOCK_OPEN_NO_IO;
210 }
Daniel P. Berrange1cd9a782017-06-23 17:24:17 +0100211 s->crypto = qcrypto_block_open(crypto_opts, "encrypt.",
212 NULL, NULL, cflags, errp);
Daniel P. Berranged85f4222017-06-23 17:24:08 +0100213 if (!s->crypto) {
214 ret = -EINVAL;
215 goto fail;
216 }
217 } else {
218 error_setg(errp, "invalid encryption method in qcow header");
219 ret = -EINVAL;
220 goto fail;
221 }
Eric Blake54115412016-06-23 16:37:26 -0600222 bs->encrypted = true;
Daniel P. Berrangec01c2142017-06-23 17:24:16 +0100223 } else {
224 if (encryptfmt) {
225 error_setg(errp, "No encryption in image header, but options "
226 "specified format '%s'", encryptfmt);
227 ret = -EINVAL;
228 goto fail;
229 }
Li Zhi Hui84b0ec02011-12-15 18:14:00 +0800230 }
bellardea2384d2004-08-01 21:59:26 +0000231 s->cluster_bits = header.cluster_bits;
232 s->cluster_size = 1 << s->cluster_bits;
233 s->cluster_sectors = 1 << (s->cluster_bits - 9);
234 s->l2_bits = header.l2_bits;
235 s->l2_size = 1 << s->l2_bits;
236 bs->total_sectors = header.size / 512;
237 s->cluster_offset_mask = (1LL << (63 - s->cluster_bits)) - 1;
238
239 /* read the level 1 table */
240 shift = s->cluster_bits + s->l2_bits;
Kevin Wolf46485de2014-05-08 13:08:20 +0200241 if (header.size > UINT64_MAX - (1LL << shift)) {
242 error_setg(errp, "Image too large");
243 ret = -EINVAL;
244 goto fail;
245 } else {
246 uint64_t l1_size = (header.size + (1LL << shift) - 1) >> shift;
247 if (l1_size > INT_MAX / sizeof(uint64_t)) {
248 error_setg(errp, "Image too large");
249 ret = -EINVAL;
250 goto fail;
251 }
252 s->l1_size = l1_size;
253 }
bellardea2384d2004-08-01 21:59:26 +0000254
255 s->l1_table_offset = header.l1_table_offset;
Markus Armbruster5839e532014-08-19 10:31:08 +0200256 s->l1_table = g_try_new(uint64_t, s->l1_size);
Kevin Wolf0df93302014-05-20 13:36:05 +0200257 if (s->l1_table == NULL) {
258 error_setg(errp, "Could not allocate memory for L1 table");
259 ret = -ENOMEM;
260 goto fail;
261 }
Li Zhi Hui84b0ec02011-12-15 18:14:00 +0800262
Kevin Wolfcf2ab8f2016-06-20 18:24:02 +0200263 ret = bdrv_pread(bs->file, s->l1_table_offset, s->l1_table,
Li Zhi Hui84b0ec02011-12-15 18:14:00 +0800264 s->l1_size * sizeof(uint64_t));
265 if (ret < 0) {
bellardea2384d2004-08-01 21:59:26 +0000266 goto fail;
Li Zhi Hui84b0ec02011-12-15 18:14:00 +0800267 }
268
bellardea2384d2004-08-01 21:59:26 +0000269 for(i = 0;i < s->l1_size; i++) {
270 be64_to_cpus(&s->l1_table[i]);
271 }
Kevin Wolf0df93302014-05-20 13:36:05 +0200272
273 /* alloc L2 cache (max. 64k * 16 * 8 = 8 MB) */
274 s->l2_cache =
Kevin Wolf9a4f4c32015-06-16 14:19:22 +0200275 qemu_try_blockalign(bs->file->bs,
Kevin Wolf0df93302014-05-20 13:36:05 +0200276 s->l2_size * L2_CACHE_SIZE * sizeof(uint64_t));
277 if (s->l2_cache == NULL) {
278 error_setg(errp, "Could not allocate L2 table cache");
279 ret = -ENOMEM;
280 goto fail;
281 }
Anthony Liguori7267c092011-08-20 22:09:37 -0500282 s->cluster_cache = g_malloc(s->cluster_size);
Anthony Liguori7267c092011-08-20 22:09:37 -0500283 s->cluster_data = g_malloc(s->cluster_size);
bellardea2384d2004-08-01 21:59:26 +0000284 s->cluster_cache_offset = -1;
ths3b46e622007-09-17 08:09:54 +0000285
bellardea2384d2004-08-01 21:59:26 +0000286 /* read the backing file name */
287 if (header.backing_file_offset != 0) {
288 len = header.backing_file_size;
Jeff Codye729fa62015-01-27 08:33:55 -0500289 if (len > 1023 || len >= sizeof(bs->backing_file)) {
Kevin Wolfd66e5ce2014-05-08 13:35:09 +0200290 error_setg(errp, "Backing file name too long");
291 ret = -EINVAL;
292 goto fail;
Li Zhi Hui84b0ec02011-12-15 18:14:00 +0800293 }
Kevin Wolfcf2ab8f2016-06-20 18:24:02 +0200294 ret = bdrv_pread(bs->file, header.backing_file_offset,
Li Zhi Hui84b0ec02011-12-15 18:14:00 +0800295 bs->backing_file, len);
296 if (ret < 0) {
bellardea2384d2004-08-01 21:59:26 +0000297 goto fail;
Li Zhi Hui84b0ec02011-12-15 18:14:00 +0800298 }
bellardea2384d2004-08-01 21:59:26 +0000299 bs->backing_file[len] = '\0';
300 }
Scott Woodde33b1f2011-08-11 16:27:15 -0500301
Kevin Wolffd9f1022011-11-22 16:44:45 +0100302 /* Disable migration when qcow images are used */
Alberto Garcia81e5f782015-04-08 12:29:19 +0300303 error_setg(&s->migration_blocker, "The qcow format used by node '%s' "
304 "does not support live migration",
305 bdrv_get_device_or_node_name(bs));
Ashijeet Acharyafe44dc92017-01-16 17:01:53 +0530306 ret = migrate_add_blocker(s->migration_blocker, &local_err);
307 if (local_err) {
308 error_propagate(errp, local_err);
309 error_free(s->migration_blocker);
310 goto fail;
311 }
Kevin Wolffd9f1022011-11-22 16:44:45 +0100312
Daniel P. Berranged85f4222017-06-23 17:24:08 +0100313 QDECREF(encryptopts);
314 qapi_free_QCryptoBlockOpenOptions(crypto_opts);
Scott Woodde33b1f2011-08-11 16:27:15 -0500315 qemu_co_mutex_init(&s->lock);
bellardea2384d2004-08-01 21:59:26 +0000316 return 0;
317
318 fail:
Anthony Liguori7267c092011-08-20 22:09:37 -0500319 g_free(s->l1_table);
Kevin Wolf0df93302014-05-20 13:36:05 +0200320 qemu_vfree(s->l2_cache);
Anthony Liguori7267c092011-08-20 22:09:37 -0500321 g_free(s->cluster_cache);
322 g_free(s->cluster_data);
Daniel P. Berranged85f4222017-06-23 17:24:08 +0100323 qcrypto_block_free(s->crypto);
324 QDECREF(encryptopts);
325 qapi_free_QCryptoBlockOpenOptions(crypto_opts);
Li Zhi Hui84b0ec02011-12-15 18:14:00 +0800326 return ret;
bellardea2384d2004-08-01 21:59:26 +0000327}
328
Jeff Codyd1776922012-09-20 15:13:29 -0400329
330/* We have nothing to do for QCOW reopen, stubs just return
331 * success */
332static int qcow_reopen_prepare(BDRVReopenState *state,
333 BlockReopenQueue *queue, Error **errp)
334{
335 return 0;
336}
337
bellardea2384d2004-08-01 21:59:26 +0000338
339/* 'allocate' is:
340 *
341 * 0 to not allocate.
342 *
343 * 1 to allocate a normal cluster (for sector indexes 'n_start' to
344 * 'n_end')
345 *
346 * 2 to allocate a compressed cluster of size
347 * 'compressed_size'. 'compressed_size' must be > 0 and <
ths5fafdf22007-09-16 21:08:06 +0000348 * cluster_size
bellardea2384d2004-08-01 21:59:26 +0000349 *
Eric Blake56439e92017-08-09 15:38:05 -0500350 * return 0 if not allocated, 1 if *result is assigned, and negative
351 * errno on failure.
bellardea2384d2004-08-01 21:59:26 +0000352 */
Eric Blake56439e92017-08-09 15:38:05 -0500353static int get_cluster_offset(BlockDriverState *bs,
354 uint64_t offset, int allocate,
355 int compressed_size,
356 int n_start, int n_end, uint64_t *result)
bellardea2384d2004-08-01 21:59:26 +0000357{
358 BDRVQcowState *s = bs->opaque;
Eric Blake56439e92017-08-09 15:38:05 -0500359 int min_index, i, j, l1_index, l2_index, ret;
Eric Blaked7a753a2017-08-09 15:38:06 -0500360 int64_t l2_offset;
361 uint64_t *l2_table, cluster_offset, tmp;
bellardea2384d2004-08-01 21:59:26 +0000362 uint32_t min_count;
363 int new_l2_table;
ths3b46e622007-09-17 08:09:54 +0000364
Eric Blake56439e92017-08-09 15:38:05 -0500365 *result = 0;
bellardea2384d2004-08-01 21:59:26 +0000366 l1_index = offset >> (s->l2_bits + s->cluster_bits);
367 l2_offset = s->l1_table[l1_index];
368 new_l2_table = 0;
369 if (!l2_offset) {
370 if (!allocate)
371 return 0;
372 /* allocate a new l2 entry */
Kevin Wolf9a4f4c32015-06-16 14:19:22 +0200373 l2_offset = bdrv_getlength(bs->file->bs);
Eric Blaked7a753a2017-08-09 15:38:06 -0500374 if (l2_offset < 0) {
375 return l2_offset;
376 }
bellardea2384d2004-08-01 21:59:26 +0000377 /* round to cluster size */
Eric Blaked7a753a2017-08-09 15:38:06 -0500378 l2_offset = QEMU_ALIGN_UP(l2_offset, s->cluster_size);
bellardea2384d2004-08-01 21:59:26 +0000379 /* update the L1 entry */
380 s->l1_table[l1_index] = l2_offset;
381 tmp = cpu_to_be64(l2_offset);
Eric Blake56439e92017-08-09 15:38:05 -0500382 ret = bdrv_pwrite_sync(bs->file,
383 s->l1_table_offset + l1_index * sizeof(tmp),
384 &tmp, sizeof(tmp));
385 if (ret < 0) {
386 return ret;
387 }
bellardea2384d2004-08-01 21:59:26 +0000388 new_l2_table = 1;
389 }
390 for(i = 0; i < L2_CACHE_SIZE; i++) {
391 if (l2_offset == s->l2_cache_offsets[i]) {
392 /* increment the hit count */
393 if (++s->l2_cache_counts[i] == 0xffffffff) {
394 for(j = 0; j < L2_CACHE_SIZE; j++) {
395 s->l2_cache_counts[j] >>= 1;
396 }
397 }
398 l2_table = s->l2_cache + (i << s->l2_bits);
399 goto found;
400 }
401 }
402 /* not found: load a new entry in the least used one */
403 min_index = 0;
404 min_count = 0xffffffff;
405 for(i = 0; i < L2_CACHE_SIZE; i++) {
406 if (s->l2_cache_counts[i] < min_count) {
407 min_count = s->l2_cache_counts[i];
408 min_index = i;
409 }
410 }
411 l2_table = s->l2_cache + (min_index << s->l2_bits);
bellardea2384d2004-08-01 21:59:26 +0000412 if (new_l2_table) {
413 memset(l2_table, 0, s->l2_size * sizeof(uint64_t));
Eric Blake56439e92017-08-09 15:38:05 -0500414 ret = bdrv_pwrite_sync(bs->file, l2_offset, l2_table,
415 s->l2_size * sizeof(uint64_t));
416 if (ret < 0) {
417 return ret;
418 }
bellardea2384d2004-08-01 21:59:26 +0000419 } else {
Eric Blake56439e92017-08-09 15:38:05 -0500420 ret = bdrv_pread(bs->file, l2_offset, l2_table,
421 s->l2_size * sizeof(uint64_t));
422 if (ret < 0) {
423 return ret;
424 }
bellardea2384d2004-08-01 21:59:26 +0000425 }
426 s->l2_cache_offsets[min_index] = l2_offset;
427 s->l2_cache_counts[min_index] = 1;
428 found:
429 l2_index = (offset >> s->cluster_bits) & (s->l2_size - 1);
430 cluster_offset = be64_to_cpu(l2_table[l2_index]);
ths5fafdf22007-09-16 21:08:06 +0000431 if (!cluster_offset ||
bellardea2384d2004-08-01 21:59:26 +0000432 ((cluster_offset & QCOW_OFLAG_COMPRESSED) && allocate == 1)) {
433 if (!allocate)
434 return 0;
435 /* allocate a new cluster */
436 if ((cluster_offset & QCOW_OFLAG_COMPRESSED) &&
437 (n_end - n_start) < s->cluster_sectors) {
438 /* if the cluster is already compressed, we must
439 decompress it in the case it is not completely
440 overwritten */
Eric Blake56439e92017-08-09 15:38:05 -0500441 if (decompress_cluster(bs, cluster_offset) < 0) {
442 return -EIO;
443 }
Kevin Wolf9a4f4c32015-06-16 14:19:22 +0200444 cluster_offset = bdrv_getlength(bs->file->bs);
Eric Blaked7a753a2017-08-09 15:38:06 -0500445 if ((int64_t) cluster_offset < 0) {
446 return cluster_offset;
447 }
448 cluster_offset = QEMU_ALIGN_UP(cluster_offset, s->cluster_size);
bellardea2384d2004-08-01 21:59:26 +0000449 /* write the cluster content */
Eric Blake56439e92017-08-09 15:38:05 -0500450 ret = bdrv_pwrite(bs->file, cluster_offset, s->cluster_cache,
451 s->cluster_size);
452 if (ret < 0) {
453 return ret;
454 }
bellardea2384d2004-08-01 21:59:26 +0000455 } else {
Kevin Wolf9a4f4c32015-06-16 14:19:22 +0200456 cluster_offset = bdrv_getlength(bs->file->bs);
Eric Blaked7a753a2017-08-09 15:38:06 -0500457 if ((int64_t) cluster_offset < 0) {
458 return cluster_offset;
459 }
aliguori7f48fa12009-01-08 19:29:03 +0000460 if (allocate == 1) {
461 /* round to cluster size */
Eric Blaked7a753a2017-08-09 15:38:06 -0500462 cluster_offset = QEMU_ALIGN_UP(cluster_offset, s->cluster_size);
463 if (cluster_offset + s->cluster_size > INT64_MAX) {
464 return -E2BIG;
465 }
466 ret = bdrv_truncate(bs->file, cluster_offset + s->cluster_size,
467 PREALLOC_MODE_OFF, NULL);
468 if (ret < 0) {
469 return ret;
470 }
aliguori7f48fa12009-01-08 19:29:03 +0000471 /* if encrypted, we must initialize the cluster
472 content which won't be written */
Daniel P. Berrange8336aaf2015-05-12 17:09:18 +0100473 if (bs->encrypted &&
aliguori7f48fa12009-01-08 19:29:03 +0000474 (n_end - n_start) < s->cluster_sectors) {
475 uint64_t start_sect;
Daniel P. Berranged85f4222017-06-23 17:24:08 +0100476 assert(s->crypto);
aliguori7f48fa12009-01-08 19:29:03 +0000477 start_sect = (offset & ~(s->cluster_size - 1)) >> 9;
aliguori7f48fa12009-01-08 19:29:03 +0000478 for(i = 0; i < s->cluster_sectors; i++) {
479 if (i < n_start || i >= n_end) {
Daniel P. Berrange1fad1f92017-06-23 17:24:07 +0100480 memset(s->cluster_data, 0x00, 512);
Daniel P. Berrange46097422017-09-27 13:53:39 +0100481 if (qcrypto_block_encrypt(s->crypto,
482 (start_sect + i) *
483 BDRV_SECTOR_SIZE,
Daniel P. Berranged85f4222017-06-23 17:24:08 +0100484 s->cluster_data,
485 BDRV_SECTOR_SIZE,
Alberto Garciac3a8fe32017-08-29 15:08:36 +0300486 NULL) < 0) {
Eric Blake56439e92017-08-09 15:38:05 -0500487 return -EIO;
Daniel P. Berrangef6fa64f2015-07-01 18:10:37 +0100488 }
Eric Blake56439e92017-08-09 15:38:05 -0500489 ret = bdrv_pwrite(bs->file,
490 cluster_offset + i * 512,
491 s->cluster_data, 512);
492 if (ret < 0) {
493 return ret;
494 }
aliguori7f48fa12009-01-08 19:29:03 +0000495 }
bellardea2384d2004-08-01 21:59:26 +0000496 }
497 }
aliguori7f48fa12009-01-08 19:29:03 +0000498 } else if (allocate == 2) {
499 cluster_offset |= QCOW_OFLAG_COMPRESSED |
500 (uint64_t)compressed_size << (63 - s->cluster_bits);
bellardea2384d2004-08-01 21:59:26 +0000501 }
502 }
503 /* update L2 table */
504 tmp = cpu_to_be64(cluster_offset);
505 l2_table[l2_index] = tmp;
Eric Blake56439e92017-08-09 15:38:05 -0500506 ret = bdrv_pwrite_sync(bs->file, l2_offset + l2_index * sizeof(tmp),
507 &tmp, sizeof(tmp));
508 if (ret < 0) {
509 return ret;
510 }
bellardea2384d2004-08-01 21:59:26 +0000511 }
Eric Blake56439e92017-08-09 15:38:05 -0500512 *result = cluster_offset;
513 return 1;
bellardea2384d2004-08-01 21:59:26 +0000514}
515
Paolo Bonzinib6b8a332013-09-04 19:00:28 +0200516static int64_t coroutine_fn qcow_co_get_block_status(BlockDriverState *bs,
Fam Zheng67a0fd22016-01-26 11:58:48 +0800517 int64_t sector_num, int nb_sectors, int *pnum, BlockDriverState **file)
bellardea2384d2004-08-01 21:59:26 +0000518{
519 BDRVQcowState *s = bs->opaque;
Eric Blake56439e92017-08-09 15:38:05 -0500520 int index_in_cluster, n, ret;
bellardea2384d2004-08-01 21:59:26 +0000521 uint64_t cluster_offset;
522
Stefan Hajnoczif8a2e5e2011-11-14 12:44:21 +0000523 qemu_co_mutex_lock(&s->lock);
Eric Blake56439e92017-08-09 15:38:05 -0500524 ret = get_cluster_offset(bs, sector_num << 9, 0, 0, 0, 0, &cluster_offset);
Stefan Hajnoczif8a2e5e2011-11-14 12:44:21 +0000525 qemu_co_mutex_unlock(&s->lock);
Eric Blake56439e92017-08-09 15:38:05 -0500526 if (ret < 0) {
527 return ret;
528 }
bellardea2384d2004-08-01 21:59:26 +0000529 index_in_cluster = sector_num & (s->cluster_sectors - 1);
530 n = s->cluster_sectors - index_in_cluster;
531 if (n > nb_sectors)
532 n = nb_sectors;
533 *pnum = n;
Paolo Bonzini4bc74be2013-09-04 19:00:30 +0200534 if (!cluster_offset) {
535 return 0;
536 }
Daniel P. Berranged85f4222017-06-23 17:24:08 +0100537 if ((cluster_offset & QCOW_OFLAG_COMPRESSED) || s->crypto) {
Paolo Bonzini4bc74be2013-09-04 19:00:30 +0200538 return BDRV_BLOCK_DATA;
539 }
540 cluster_offset |= (index_in_cluster << BDRV_SECTOR_BITS);
Fam Zheng3064bf62016-01-26 11:58:49 +0800541 *file = bs->file->bs;
Paolo Bonzini4bc74be2013-09-04 19:00:30 +0200542 return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID | cluster_offset;
bellardea2384d2004-08-01 21:59:26 +0000543}
544
545static int decompress_buffer(uint8_t *out_buf, int out_buf_size,
546 const uint8_t *buf, int buf_size)
547{
548 z_stream strm1, *strm = &strm1;
549 int ret, out_len;
550
551 memset(strm, 0, sizeof(*strm));
552
553 strm->next_in = (uint8_t *)buf;
554 strm->avail_in = buf_size;
555 strm->next_out = out_buf;
556 strm->avail_out = out_buf_size;
557
558 ret = inflateInit2(strm, -12);
559 if (ret != Z_OK)
560 return -1;
561 ret = inflate(strm, Z_FINISH);
562 out_len = strm->next_out - out_buf;
563 if ((ret != Z_STREAM_END && ret != Z_BUF_ERROR) ||
564 out_len != out_buf_size) {
565 inflateEnd(strm);
566 return -1;
567 }
568 inflateEnd(strm);
569 return 0;
570}
ths3b46e622007-09-17 08:09:54 +0000571
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200572static int decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset)
bellardea2384d2004-08-01 21:59:26 +0000573{
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200574 BDRVQcowState *s = bs->opaque;
bellardea2384d2004-08-01 21:59:26 +0000575 int ret, csize;
576 uint64_t coffset;
577
578 coffset = cluster_offset & s->cluster_offset_mask;
579 if (s->cluster_cache_offset != coffset) {
580 csize = cluster_offset >> (63 - s->cluster_bits);
581 csize &= (s->cluster_size - 1);
Kevin Wolfcf2ab8f2016-06-20 18:24:02 +0200582 ret = bdrv_pread(bs->file, coffset, s->cluster_data, csize);
ths5fafdf22007-09-16 21:08:06 +0000583 if (ret != csize)
bellardea2384d2004-08-01 21:59:26 +0000584 return -1;
585 if (decompress_buffer(s->cluster_cache, s->cluster_size,
586 s->cluster_data, csize) < 0) {
587 return -1;
588 }
589 s->cluster_cache_offset = coffset;
590 }
591 return 0;
592}
593
Dong Xu Wanga9681682011-11-10 16:23:22 +0800594static coroutine_fn int qcow_co_readv(BlockDriverState *bs, int64_t sector_num,
Kevin Wolf52b8eb62011-07-15 16:27:42 +0200595 int nb_sectors, QEMUIOVector *qiov)
596{
597 BDRVQcowState *s = bs->opaque;
Frediano Ziglio27deebe2011-08-23 15:21:11 +0200598 int index_in_cluster;
599 int ret = 0, n;
600 uint64_t cluster_offset;
601 struct iovec hd_iov;
602 QEMUIOVector hd_qiov;
603 uint8_t *buf;
604 void *orig_buf;
Kevin Wolf52b8eb62011-07-15 16:27:42 +0200605
Frediano Ziglio27deebe2011-08-23 15:21:11 +0200606 if (qiov->niov > 1) {
Kevin Wolf0df93302014-05-20 13:36:05 +0200607 buf = orig_buf = qemu_try_blockalign(bs, qiov->size);
608 if (buf == NULL) {
609 return -ENOMEM;
610 }
Frediano Ziglio27deebe2011-08-23 15:21:11 +0200611 } else {
612 orig_buf = NULL;
613 buf = (uint8_t *)qiov->iov->iov_base;
614 }
Kevin Wolf52b8eb62011-07-15 16:27:42 +0200615
616 qemu_co_mutex_lock(&s->lock);
Frediano Ziglio27deebe2011-08-23 15:21:11 +0200617
618 while (nb_sectors != 0) {
619 /* prepare next request */
Eric Blake56439e92017-08-09 15:38:05 -0500620 ret = get_cluster_offset(bs, sector_num << 9,
621 0, 0, 0, 0, &cluster_offset);
622 if (ret < 0) {
623 break;
624 }
Frediano Ziglio27deebe2011-08-23 15:21:11 +0200625 index_in_cluster = sector_num & (s->cluster_sectors - 1);
626 n = s->cluster_sectors - index_in_cluster;
627 if (n > nb_sectors) {
628 n = nb_sectors;
629 }
630
631 if (!cluster_offset) {
Kevin Wolf760e0062015-06-17 14:55:21 +0200632 if (bs->backing) {
Frediano Ziglio27deebe2011-08-23 15:21:11 +0200633 /* read from the base image */
634 hd_iov.iov_base = (void *)buf;
635 hd_iov.iov_len = n * 512;
636 qemu_iovec_init_external(&hd_qiov, &hd_iov, 1);
637 qemu_co_mutex_unlock(&s->lock);
Kevin Wolf28b04a82016-05-24 17:21:22 +0200638 ret = bdrv_co_readv(bs->backing, sector_num, n, &hd_qiov);
Frediano Ziglio27deebe2011-08-23 15:21:11 +0200639 qemu_co_mutex_lock(&s->lock);
640 if (ret < 0) {
Eric Blake56439e92017-08-09 15:38:05 -0500641 break;
Frediano Ziglio27deebe2011-08-23 15:21:11 +0200642 }
643 } else {
644 /* Note: in this case, no need to wait */
645 memset(buf, 0, 512 * n);
646 }
647 } else if (cluster_offset & QCOW_OFLAG_COMPRESSED) {
648 /* add AIO support for compressed blocks ? */
649 if (decompress_cluster(bs, cluster_offset) < 0) {
Eric Blake56439e92017-08-09 15:38:05 -0500650 ret = -EIO;
651 break;
Frediano Ziglio27deebe2011-08-23 15:21:11 +0200652 }
653 memcpy(buf,
654 s->cluster_cache + index_in_cluster * 512, 512 * n);
655 } else {
656 if ((cluster_offset & 511) != 0) {
Eric Blake56439e92017-08-09 15:38:05 -0500657 ret = -EIO;
658 break;
Frediano Ziglio27deebe2011-08-23 15:21:11 +0200659 }
660 hd_iov.iov_base = (void *)buf;
661 hd_iov.iov_len = n * 512;
662 qemu_iovec_init_external(&hd_qiov, &hd_iov, 1);
663 qemu_co_mutex_unlock(&s->lock);
Kevin Wolf28b04a82016-05-24 17:21:22 +0200664 ret = bdrv_co_readv(bs->file,
Frediano Ziglio27deebe2011-08-23 15:21:11 +0200665 (cluster_offset >> 9) + index_in_cluster,
666 n, &hd_qiov);
667 qemu_co_mutex_lock(&s->lock);
668 if (ret < 0) {
669 break;
670 }
Daniel P. Berrange8336aaf2015-05-12 17:09:18 +0100671 if (bs->encrypted) {
Daniel P. Berranged85f4222017-06-23 17:24:08 +0100672 assert(s->crypto);
Daniel P. Berrange46097422017-09-27 13:53:39 +0100673 if (qcrypto_block_decrypt(s->crypto,
674 sector_num * BDRV_SECTOR_SIZE, buf,
Alberto Garciac3a8fe32017-08-29 15:08:36 +0300675 n * BDRV_SECTOR_SIZE, NULL) < 0) {
Eric Blake56439e92017-08-09 15:38:05 -0500676 ret = -EIO;
677 break;
Daniel P. Berrangef6fa64f2015-07-01 18:10:37 +0100678 }
Frediano Ziglio27deebe2011-08-23 15:21:11 +0200679 }
680 }
681 ret = 0;
682
683 nb_sectors -= n;
684 sector_num += n;
685 buf += n * 512;
686 }
687
Kevin Wolf52b8eb62011-07-15 16:27:42 +0200688 qemu_co_mutex_unlock(&s->lock);
689
Frediano Ziglio27deebe2011-08-23 15:21:11 +0200690 if (qiov->niov > 1) {
Michael Tokarev03396142012-06-07 20:17:55 +0400691 qemu_iovec_from_buf(qiov, 0, orig_buf, qiov->size);
Frediano Ziglio27deebe2011-08-23 15:21:11 +0200692 qemu_vfree(orig_buf);
aliguorif141eaf2009-04-07 18:43:24 +0000693 }
Kevin Wolf52b8eb62011-07-15 16:27:42 +0200694
695 return ret;
bellard83f64092006-08-01 16:21:11 +0000696}
697
Dong Xu Wanga9681682011-11-10 16:23:22 +0800698static coroutine_fn int qcow_co_writev(BlockDriverState *bs, int64_t sector_num,
Kevin Wolf52b8eb62011-07-15 16:27:42 +0200699 int nb_sectors, QEMUIOVector *qiov)
bellard83f64092006-08-01 16:21:11 +0000700{
bellard83f64092006-08-01 16:21:11 +0000701 BDRVQcowState *s = bs->opaque;
Frediano Ziglio27deebe2011-08-23 15:21:11 +0200702 int index_in_cluster;
703 uint64_t cluster_offset;
Frediano Ziglio27deebe2011-08-23 15:21:11 +0200704 int ret = 0, n;
Frediano Ziglio27deebe2011-08-23 15:21:11 +0200705 struct iovec hd_iov;
706 QEMUIOVector hd_qiov;
707 uint8_t *buf;
708 void *orig_buf;
ths3b46e622007-09-17 08:09:54 +0000709
bellard83f64092006-08-01 16:21:11 +0000710 s->cluster_cache_offset = -1; /* disable compressed cache */
711
Daniel P. Berrange1fad1f92017-06-23 17:24:07 +0100712 /* We must always copy the iov when encrypting, so we
713 * don't modify the original data buffer during encryption */
714 if (bs->encrypted || qiov->niov > 1) {
Kevin Wolf0df93302014-05-20 13:36:05 +0200715 buf = orig_buf = qemu_try_blockalign(bs, qiov->size);
716 if (buf == NULL) {
717 return -ENOMEM;
718 }
Michael Tokarevd5e6b162012-06-07 20:21:06 +0400719 qemu_iovec_to_buf(qiov, 0, buf, qiov->size);
Frediano Ziglio27deebe2011-08-23 15:21:11 +0200720 } else {
721 orig_buf = NULL;
722 buf = (uint8_t *)qiov->iov->iov_base;
723 }
Christoph Hellwigad530892009-05-25 15:45:37 +0200724
Kevin Wolf52b8eb62011-07-15 16:27:42 +0200725 qemu_co_mutex_lock(&s->lock);
Frediano Ziglio27deebe2011-08-23 15:21:11 +0200726
727 while (nb_sectors != 0) {
728
729 index_in_cluster = sector_num & (s->cluster_sectors - 1);
730 n = s->cluster_sectors - index_in_cluster;
731 if (n > nb_sectors) {
732 n = nb_sectors;
733 }
Eric Blake56439e92017-08-09 15:38:05 -0500734 ret = get_cluster_offset(bs, sector_num << 9, 1, 0,
735 index_in_cluster,
736 index_in_cluster + n, &cluster_offset);
737 if (ret < 0) {
738 break;
739 }
Frediano Ziglio27deebe2011-08-23 15:21:11 +0200740 if (!cluster_offset || (cluster_offset & 511) != 0) {
741 ret = -EIO;
742 break;
743 }
Daniel P. Berrange8336aaf2015-05-12 17:09:18 +0100744 if (bs->encrypted) {
Daniel P. Berranged85f4222017-06-23 17:24:08 +0100745 assert(s->crypto);
Daniel P. Berrange46097422017-09-27 13:53:39 +0100746 if (qcrypto_block_encrypt(s->crypto, sector_num * BDRV_SECTOR_SIZE,
747 buf, n * BDRV_SECTOR_SIZE, NULL) < 0) {
Daniel P. Berrangef6fa64f2015-07-01 18:10:37 +0100748 ret = -EIO;
749 break;
750 }
Frediano Ziglio27deebe2011-08-23 15:21:11 +0200751 }
752
Daniel P. Berrange1fad1f92017-06-23 17:24:07 +0100753 hd_iov.iov_base = (void *)buf;
Frediano Ziglio27deebe2011-08-23 15:21:11 +0200754 hd_iov.iov_len = n * 512;
755 qemu_iovec_init_external(&hd_qiov, &hd_iov, 1);
756 qemu_co_mutex_unlock(&s->lock);
Kevin Wolf25ec1772016-05-24 17:21:22 +0200757 ret = bdrv_co_writev(bs->file,
Frediano Ziglio27deebe2011-08-23 15:21:11 +0200758 (cluster_offset >> 9) + index_in_cluster,
759 n, &hd_qiov);
760 qemu_co_mutex_lock(&s->lock);
761 if (ret < 0) {
762 break;
763 }
764 ret = 0;
765
766 nb_sectors -= n;
767 sector_num += n;
768 buf += n * 512;
769 }
Kevin Wolf52b8eb62011-07-15 16:27:42 +0200770 qemu_co_mutex_unlock(&s->lock);
ths3b46e622007-09-17 08:09:54 +0000771
Daniel P. Berrange1fad1f92017-06-23 17:24:07 +0100772 qemu_vfree(orig_buf);
Kevin Wolfb11a24d2011-06-07 15:20:44 +0200773
Kevin Wolf52b8eb62011-07-15 16:27:42 +0200774 return ret;
bellard83f64092006-08-01 16:21:11 +0000775}
776
bellarde2731ad2004-09-18 19:32:11 +0000777static void qcow_close(BlockDriverState *bs)
bellardea2384d2004-08-01 21:59:26 +0000778{
779 BDRVQcowState *s = bs->opaque;
Kevin Wolffd9f1022011-11-22 16:44:45 +0100780
Daniel P. Berranged85f4222017-06-23 17:24:08 +0100781 qcrypto_block_free(s->crypto);
782 s->crypto = NULL;
Anthony Liguori7267c092011-08-20 22:09:37 -0500783 g_free(s->l1_table);
Kevin Wolf0df93302014-05-20 13:36:05 +0200784 qemu_vfree(s->l2_cache);
Anthony Liguori7267c092011-08-20 22:09:37 -0500785 g_free(s->cluster_cache);
786 g_free(s->cluster_data);
Kevin Wolffd9f1022011-11-22 16:44:45 +0100787
788 migrate_del_blocker(s->migration_blocker);
789 error_free(s->migration_blocker);
bellardea2384d2004-08-01 21:59:26 +0000790}
791
Chunyan Liu16d12152014-06-05 17:20:57 +0800792static int qcow_create(const char *filename, QemuOpts *opts, Error **errp)
bellardea2384d2004-08-01 21:59:26 +0000793{
Li Zhi Hui2b16c9f2011-11-21 15:40:39 +0800794 int header_size, backing_filename_len, l1_size, shift, i;
bellardea2384d2004-08-01 21:59:26 +0000795 QCowHeader header;
Li Zhi Hui2b16c9f2011-11-21 15:40:39 +0800796 uint8_t *tmp;
Kevin Wolf0e7e1982009-05-18 16:42:10 +0200797 int64_t total_size = 0;
Chunyan Liu16d12152014-06-05 17:20:57 +0800798 char *backing_file = NULL;
Max Reitz34b5d2c2013-09-05 14:45:29 +0200799 Error *local_err = NULL;
Kirill A. Shutemov3e1a8132010-01-20 00:56:12 +0100800 int ret;
Kevin Wolf6af40162016-03-08 15:57:05 +0100801 BlockBackend *qcow_blk;
Daniel P. Berrange0696ae22017-07-14 11:31:05 +0100802 char *encryptfmt = NULL;
Daniel P. Berranged85f4222017-06-23 17:24:08 +0100803 QDict *options;
804 QDict *encryptopts = NULL;
805 QCryptoBlockCreateOptions *crypto_opts = NULL;
806 QCryptoBlock *crypto = NULL;
Kevin Wolf0e7e1982009-05-18 16:42:10 +0200807
808 /* Read out options */
Hu Tao180e9522014-09-10 17:05:46 +0800809 total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
810 BDRV_SECTOR_SIZE);
Daniel P. Berrange6aa837f2017-06-23 17:24:03 +0100811 if (total_size == 0) {
812 error_setg(errp, "Image size is too small, cannot be zero length");
813 ret = -EINVAL;
814 goto cleanup;
815 }
816
Chunyan Liu16d12152014-06-05 17:20:57 +0800817 backing_file = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FILE);
Daniel P. Berrange0cb8d472017-06-23 17:24:06 +0100818 encryptfmt = qemu_opt_get_del(opts, BLOCK_OPT_ENCRYPT_FORMAT);
819 if (encryptfmt) {
820 if (qemu_opt_get(opts, BLOCK_OPT_ENCRYPT)) {
821 error_setg(errp, "Options " BLOCK_OPT_ENCRYPT " and "
822 BLOCK_OPT_ENCRYPT_FORMAT " are mutually exclusive");
823 ret = -EINVAL;
824 goto cleanup;
825 }
826 } else if (qemu_opt_get_bool_del(opts, BLOCK_OPT_ENCRYPT, false)) {
Daniel P. Berrange0696ae22017-07-14 11:31:05 +0100827 encryptfmt = g_strdup("aes");
Kevin Wolf0e7e1982009-05-18 16:42:10 +0200828 }
bellardea2384d2004-08-01 21:59:26 +0000829
Chunyan Liuc282e1f2014-06-05 17:21:11 +0800830 ret = bdrv_create_file(filename, opts, &local_err);
Li Zhi Hui2b16c9f2011-11-21 15:40:39 +0800831 if (ret < 0) {
Paolo Bonzinib6d50662014-02-17 14:43:58 +0100832 error_propagate(errp, local_err);
Chunyan Liu16d12152014-06-05 17:20:57 +0800833 goto cleanup;
Li Zhi Hui2b16c9f2011-11-21 15:40:39 +0800834 }
835
Max Reitzefaa7c42016-03-16 19:54:38 +0100836 qcow_blk = blk_new_open(filename, NULL, NULL,
Kevin Wolf55880602017-02-17 15:07:38 +0100837 BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL,
838 &local_err);
Kevin Wolf6af40162016-03-08 15:57:05 +0100839 if (qcow_blk == NULL) {
Paolo Bonzinib6d50662014-02-17 14:43:58 +0100840 error_propagate(errp, local_err);
Kevin Wolf6af40162016-03-08 15:57:05 +0100841 ret = -EIO;
Chunyan Liu16d12152014-06-05 17:20:57 +0800842 goto cleanup;
Li Zhi Hui2b16c9f2011-11-21 15:40:39 +0800843 }
844
Kevin Wolf6af40162016-03-08 15:57:05 +0100845 blk_set_allow_write_beyond_eof(qcow_blk, true);
846
Max Reitz3a691c52017-06-13 22:20:54 +0200847 ret = blk_truncate(qcow_blk, 0, PREALLOC_MODE_OFF, errp);
Li Zhi Hui2b16c9f2011-11-21 15:40:39 +0800848 if (ret < 0) {
849 goto exit;
850 }
851
bellardea2384d2004-08-01 21:59:26 +0000852 memset(&header, 0, sizeof(header));
853 header.magic = cpu_to_be32(QCOW_MAGIC);
854 header.version = cpu_to_be32(QCOW_VERSION);
Hu Tao180e9522014-09-10 17:05:46 +0800855 header.size = cpu_to_be64(total_size);
bellardea2384d2004-08-01 21:59:26 +0000856 header_size = sizeof(header);
857 backing_filename_len = 0;
858 if (backing_file) {
aurel327852e5d2008-03-18 06:52:48 +0000859 if (strcmp(backing_file, "fat:")) {
860 header.backing_file_offset = cpu_to_be64(header_size);
861 backing_filename_len = strlen(backing_file);
862 header.backing_file_size = cpu_to_be32(backing_filename_len);
863 header_size += backing_filename_len;
864 } else {
865 /* special backing file for vvfat */
Peter Maydell272545c2017-06-05 14:55:54 +0100866 g_free(backing_file);
aurel327852e5d2008-03-18 06:52:48 +0000867 backing_file = NULL;
868 }
bellardea2384d2004-08-01 21:59:26 +0000869 header.cluster_bits = 9; /* 512 byte cluster to avoid copying
Deepak Kathayatdc6fb732014-03-24 16:30:17 +0800870 unmodified sectors */
bellardea2384d2004-08-01 21:59:26 +0000871 header.l2_bits = 12; /* 32 KB L2 tables */
872 } else {
873 header.cluster_bits = 12; /* 4 KB clusters */
874 header.l2_bits = 9; /* 4 KB L2 tables */
875 }
876 header_size = (header_size + 7) & ~7;
877 shift = header.cluster_bits + header.l2_bits;
Hu Tao180e9522014-09-10 17:05:46 +0800878 l1_size = (total_size + (1LL << shift) - 1) >> shift;
bellardea2384d2004-08-01 21:59:26 +0000879
880 header.l1_table_offset = cpu_to_be64(header_size);
Daniel P. Berranged85f4222017-06-23 17:24:08 +0100881
882 options = qemu_opts_to_qdict(opts, NULL);
883 qdict_extract_subqdict(options, &encryptopts, "encrypt.");
884 QDECREF(options);
Daniel P. Berrange0cb8d472017-06-23 17:24:06 +0100885 if (encryptfmt) {
886 if (!g_str_equal(encryptfmt, "aes")) {
887 error_setg(errp, "Unknown encryption format '%s', expected 'aes'",
888 encryptfmt);
889 ret = -EINVAL;
890 goto exit;
891 }
bellardea2384d2004-08-01 21:59:26 +0000892 header.crypt_method = cpu_to_be32(QCOW_CRYPT_AES);
Daniel P. Berranged85f4222017-06-23 17:24:08 +0100893
894 crypto_opts = block_crypto_create_opts_init(
895 Q_CRYPTO_BLOCK_FORMAT_QCOW, encryptopts, errp);
896 if (!crypto_opts) {
897 ret = -EINVAL;
898 goto exit;
899 }
900
Daniel P. Berrange1cd9a782017-06-23 17:24:17 +0100901 crypto = qcrypto_block_create(crypto_opts, "encrypt.",
902 NULL, NULL, NULL, errp);
Daniel P. Berranged85f4222017-06-23 17:24:08 +0100903 if (!crypto) {
904 ret = -EINVAL;
905 goto exit;
906 }
bellardea2384d2004-08-01 21:59:26 +0000907 } else {
908 header.crypt_method = cpu_to_be32(QCOW_CRYPT_NONE);
909 }
ths3b46e622007-09-17 08:09:54 +0000910
bellardea2384d2004-08-01 21:59:26 +0000911 /* write all the data */
Eric Blake8341f002016-05-06 10:26:27 -0600912 ret = blk_pwrite(qcow_blk, 0, &header, sizeof(header), 0);
Kirill A. Shutemov3e1a8132010-01-20 00:56:12 +0100913 if (ret != sizeof(header)) {
Kirill A. Shutemov3e1a8132010-01-20 00:56:12 +0100914 goto exit;
915 }
916
bellardea2384d2004-08-01 21:59:26 +0000917 if (backing_file) {
Kevin Wolf6af40162016-03-08 15:57:05 +0100918 ret = blk_pwrite(qcow_blk, sizeof(header),
Eric Blake8341f002016-05-06 10:26:27 -0600919 backing_file, backing_filename_len, 0);
Kirill A. Shutemov3e1a8132010-01-20 00:56:12 +0100920 if (ret != backing_filename_len) {
Kirill A. Shutemov3e1a8132010-01-20 00:56:12 +0100921 goto exit;
922 }
bellardea2384d2004-08-01 21:59:26 +0000923 }
Kirill A. Shutemov3e1a8132010-01-20 00:56:12 +0100924
Li Zhi Hui2b16c9f2011-11-21 15:40:39 +0800925 tmp = g_malloc0(BDRV_SECTOR_SIZE);
Laurent Vivierd737b782016-05-31 18:35:52 +0200926 for (i = 0; i < DIV_ROUND_UP(sizeof(uint64_t) * l1_size, BDRV_SECTOR_SIZE);
927 i++) {
Eric Blake8341f002016-05-06 10:26:27 -0600928 ret = blk_pwrite(qcow_blk, header_size + BDRV_SECTOR_SIZE * i,
929 tmp, BDRV_SECTOR_SIZE, 0);
Li Zhi Hui2b16c9f2011-11-21 15:40:39 +0800930 if (ret != BDRV_SECTOR_SIZE) {
931 g_free(tmp);
932 goto exit;
933 }
934 }
935
936 g_free(tmp);
Kirill A. Shutemov3e1a8132010-01-20 00:56:12 +0100937 ret = 0;
938exit:
Kevin Wolf6af40162016-03-08 15:57:05 +0100939 blk_unref(qcow_blk);
Chunyan Liu16d12152014-06-05 17:20:57 +0800940cleanup:
Daniel P. Berranged85f4222017-06-23 17:24:08 +0100941 QDECREF(encryptopts);
Daniel P. Berrange0696ae22017-07-14 11:31:05 +0100942 g_free(encryptfmt);
Daniel P. Berranged85f4222017-06-23 17:24:08 +0100943 qcrypto_block_free(crypto);
944 qapi_free_QCryptoBlockCreateOptions(crypto_opts);
Chunyan Liu16d12152014-06-05 17:20:57 +0800945 g_free(backing_file);
Kirill A. Shutemov3e1a8132010-01-20 00:56:12 +0100946 return ret;
bellardea2384d2004-08-01 21:59:26 +0000947}
948
bellardc47c33b2006-08-05 21:32:10 +0000949static int qcow_make_empty(BlockDriverState *bs)
bellard95389c82005-12-18 18:28:15 +0000950{
951 BDRVQcowState *s = bs->opaque;
952 uint32_t l1_length = s->l1_size * sizeof(uint64_t);
bellard83f64092006-08-01 16:21:11 +0000953 int ret;
bellard95389c82005-12-18 18:28:15 +0000954
955 memset(s->l1_table, 0, l1_length);
Kevin Wolfd9ca2ea2016-06-20 20:09:15 +0200956 if (bdrv_pwrite_sync(bs->file, s->l1_table_offset, s->l1_table,
Kevin Wolf5e5557d2010-06-18 16:11:53 +0200957 l1_length) < 0)
958 return -1;
Max Reitz7ea37c32017-06-13 22:20:53 +0200959 ret = bdrv_truncate(bs->file, s->l1_table_offset + l1_length,
960 PREALLOC_MODE_OFF, NULL);
bellard83f64092006-08-01 16:21:11 +0000961 if (ret < 0)
962 return ret;
bellard95389c82005-12-18 18:28:15 +0000963
964 memset(s->l2_cache, 0, s->l2_size * L2_CACHE_SIZE * sizeof(uint64_t));
965 memset(s->l2_cache_offsets, 0, L2_CACHE_SIZE * sizeof(uint64_t));
966 memset(s->l2_cache_counts, 0, L2_CACHE_SIZE * sizeof(uint32_t));
967
968 return 0;
969}
970
bellardea2384d2004-08-01 21:59:26 +0000971/* XXX: put compressed sectors first, then all the cluster aligned
972 tables to avoid losing bytes in alignment */
Pavel Butsykinf2b95a12016-07-22 11:17:46 +0300973static coroutine_fn int
974qcow_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
975 uint64_t bytes, QEMUIOVector *qiov)
bellardea2384d2004-08-01 21:59:26 +0000976{
977 BDRVQcowState *s = bs->opaque;
Pavel Butsykinf2b95a12016-07-22 11:17:46 +0300978 QEMUIOVector hd_qiov;
979 struct iovec iov;
bellardea2384d2004-08-01 21:59:26 +0000980 z_stream strm;
981 int ret, out_len;
Pavel Butsykinf2b95a12016-07-22 11:17:46 +0300982 uint8_t *buf, *out_buf;
bellardea2384d2004-08-01 21:59:26 +0000983 uint64_t cluster_offset;
984
Pavel Butsykinf2b95a12016-07-22 11:17:46 +0300985 buf = qemu_blockalign(bs, s->cluster_size);
Pavel Butsykin655923d2016-07-22 11:17:47 +0300986 if (bytes != s->cluster_size) {
987 if (bytes > s->cluster_size ||
988 offset + bytes != bs->total_sectors << BDRV_SECTOR_BITS)
989 {
990 qemu_vfree(buf);
991 return -EINVAL;
992 }
993 /* Zero-pad last write if image size is not cluster aligned */
994 memset(buf + bytes, 0, s->cluster_size - bytes);
995 }
Pavel Butsykinf2b95a12016-07-22 11:17:46 +0300996 qemu_iovec_to_buf(qiov, 0, buf, qiov->size);
bellardea2384d2004-08-01 21:59:26 +0000997
Vladimir Sementsov-Ogievskiyebf7bba2016-07-14 19:59:25 +0300998 out_buf = g_malloc(s->cluster_size);
bellardea2384d2004-08-01 21:59:26 +0000999
1000 /* best compression, small window, no zlib header */
1001 memset(&strm, 0, sizeof(strm));
1002 ret = deflateInit2(&strm, Z_DEFAULT_COMPRESSION,
ths5fafdf22007-09-16 21:08:06 +00001003 Z_DEFLATED, -12,
bellardea2384d2004-08-01 21:59:26 +00001004 9, Z_DEFAULT_STRATEGY);
1005 if (ret != 0) {
Kevin Wolf64ebe712011-10-26 11:21:50 +02001006 ret = -EINVAL;
1007 goto fail;
bellardea2384d2004-08-01 21:59:26 +00001008 }
1009
1010 strm.avail_in = s->cluster_size;
1011 strm.next_in = (uint8_t *)buf;
1012 strm.avail_out = s->cluster_size;
1013 strm.next_out = out_buf;
1014
1015 ret = deflate(&strm, Z_FINISH);
1016 if (ret != Z_STREAM_END && ret != Z_OK) {
bellardea2384d2004-08-01 21:59:26 +00001017 deflateEnd(&strm);
Kevin Wolf64ebe712011-10-26 11:21:50 +02001018 ret = -EINVAL;
1019 goto fail;
bellardea2384d2004-08-01 21:59:26 +00001020 }
1021 out_len = strm.next_out - out_buf;
1022
1023 deflateEnd(&strm);
1024
1025 if (ret != Z_STREAM_END || out_len >= s->cluster_size) {
1026 /* could not compress: write normal cluster */
Pavel Butsykinf2b95a12016-07-22 11:17:46 +03001027 ret = qcow_co_writev(bs, offset >> BDRV_SECTOR_BITS,
1028 bytes >> BDRV_SECTOR_BITS, qiov);
Kevin Wolf64ebe712011-10-26 11:21:50 +02001029 if (ret < 0) {
1030 goto fail;
1031 }
Pavel Butsykinf2b95a12016-07-22 11:17:46 +03001032 goto success;
bellardea2384d2004-08-01 21:59:26 +00001033 }
Pavel Butsykinf2b95a12016-07-22 11:17:46 +03001034 qemu_co_mutex_lock(&s->lock);
Eric Blake56439e92017-08-09 15:38:05 -05001035 ret = get_cluster_offset(bs, offset, 2, out_len, 0, 0, &cluster_offset);
Pavel Butsykinf2b95a12016-07-22 11:17:46 +03001036 qemu_co_mutex_unlock(&s->lock);
Eric Blake56439e92017-08-09 15:38:05 -05001037 if (ret < 0) {
1038 goto fail;
1039 }
Pavel Butsykinf2b95a12016-07-22 11:17:46 +03001040 if (cluster_offset == 0) {
1041 ret = -EIO;
1042 goto fail;
1043 }
1044 cluster_offset &= s->cluster_offset_mask;
ths3b46e622007-09-17 08:09:54 +00001045
Pavel Butsykinf2b95a12016-07-22 11:17:46 +03001046 iov = (struct iovec) {
1047 .iov_base = out_buf,
1048 .iov_len = out_len,
1049 };
1050 qemu_iovec_init_external(&hd_qiov, &iov, 1);
1051 ret = bdrv_co_pwritev(bs->file, cluster_offset, out_len, &hd_qiov, 0);
1052 if (ret < 0) {
1053 goto fail;
1054 }
1055success:
Kevin Wolf64ebe712011-10-26 11:21:50 +02001056 ret = 0;
1057fail:
Pavel Butsykinf2b95a12016-07-22 11:17:46 +03001058 qemu_vfree(buf);
Anthony Liguori7267c092011-08-20 22:09:37 -05001059 g_free(out_buf);
Kevin Wolf64ebe712011-10-26 11:21:50 +02001060 return ret;
bellardea2384d2004-08-01 21:59:26 +00001061}
1062
bellardc47c33b2006-08-05 21:32:10 +00001063static int qcow_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
1064{
1065 BDRVQcowState *s = bs->opaque;
1066 bdi->cluster_size = s->cluster_size;
1067 return 0;
1068}
1069
Chunyan Liu16d12152014-06-05 17:20:57 +08001070static QemuOptsList qcow_create_opts = {
1071 .name = "qcow-create-opts",
1072 .head = QTAILQ_HEAD_INITIALIZER(qcow_create_opts.head),
1073 .desc = {
1074 {
1075 .name = BLOCK_OPT_SIZE,
1076 .type = QEMU_OPT_SIZE,
1077 .help = "Virtual disk size"
1078 },
1079 {
1080 .name = BLOCK_OPT_BACKING_FILE,
1081 .type = QEMU_OPT_STRING,
1082 .help = "File name of a base image"
1083 },
1084 {
1085 .name = BLOCK_OPT_ENCRYPT,
1086 .type = QEMU_OPT_BOOL,
Daniel P. Berrange0cb8d472017-06-23 17:24:06 +01001087 .help = "Encrypt the image with format 'aes'. (Deprecated "
1088 "in favor of " BLOCK_OPT_ENCRYPT_FORMAT "=aes)",
1089 },
1090 {
1091 .name = BLOCK_OPT_ENCRYPT_FORMAT,
1092 .type = QEMU_OPT_STRING,
1093 .help = "Encrypt the image, format choices: 'aes'",
Chunyan Liu16d12152014-06-05 17:20:57 +08001094 },
Daniel P. Berranged85f4222017-06-23 17:24:08 +01001095 BLOCK_CRYPTO_OPT_DEF_QCOW_KEY_SECRET("encrypt."),
Chunyan Liu16d12152014-06-05 17:20:57 +08001096 { /* end of list */ }
1097 }
Kevin Wolf0e7e1982009-05-18 16:42:10 +02001098};
1099
Anthony Liguori5efa9d52009-05-09 17:03:42 -05001100static BlockDriver bdrv_qcow = {
aurel32e60f4692009-03-07 22:00:29 +00001101 .format_name = "qcow",
1102 .instance_size = sizeof(BDRVQcowState),
1103 .bdrv_probe = qcow_probe,
1104 .bdrv_open = qcow_open,
1105 .bdrv_close = qcow_close,
Kevin Wolf862f2152016-12-19 16:36:02 +01001106 .bdrv_child_perm = bdrv_format_default_perms,
Chunyan Liu16d12152014-06-05 17:20:57 +08001107 .bdrv_reopen_prepare = qcow_reopen_prepare,
Chunyan Liuc282e1f2014-06-05 17:21:11 +08001108 .bdrv_create = qcow_create,
Peter Lieven3ac21622013-06-28 12:47:42 +02001109 .bdrv_has_zero_init = bdrv_has_zero_init_1,
Kevin Wolf8ee79e72014-06-04 15:09:35 +02001110 .supports_backing = true,
Kevin Wolfc68b89a2011-11-10 17:25:44 +01001111
1112 .bdrv_co_readv = qcow_co_readv,
1113 .bdrv_co_writev = qcow_co_writev,
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02001114 .bdrv_co_get_block_status = qcow_co_get_block_status,
Kevin Wolfc68b89a2011-11-10 17:25:44 +01001115
Kevin Wolfc68b89a2011-11-10 17:25:44 +01001116 .bdrv_make_empty = qcow_make_empty,
Pavel Butsykinf2b95a12016-07-22 11:17:46 +03001117 .bdrv_co_pwritev_compressed = qcow_co_pwritev_compressed,
Kevin Wolfc68b89a2011-11-10 17:25:44 +01001118 .bdrv_get_info = qcow_get_info,
Kevin Wolf0e7e1982009-05-18 16:42:10 +02001119
Chunyan Liu16d12152014-06-05 17:20:57 +08001120 .create_opts = &qcow_create_opts,
bellardea2384d2004-08-01 21:59:26 +00001121};
Anthony Liguori5efa9d52009-05-09 17:03:42 -05001122
1123static void bdrv_qcow_init(void)
1124{
1125 bdrv_register(&bdrv_qcow);
1126}
1127
1128block_init(bdrv_qcow_init);