blob: 48e1b956896841aa62544c07d151e04b918e8d74 [file] [log] [blame]
bellard585f8582006-08-05 21:14:20 +00001/*
2 * Block driver for the QCOW version 2 format
ths5fafdf22007-09-16 21:08:06 +00003 *
bellard585f8582006-08-05 21:14:20 +00004 * Copyright (c) 2004-2006 Fabrice Bellard
ths5fafdf22007-09-16 21:08:06 +00005 *
bellard585f8582006-08-05 21:14:20 +00006 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
pbrookfaf07962007-11-11 02:51:17 +000024#include "qemu-common.h"
bellard585f8582006-08-05 21:14:20 +000025#include "block_int.h"
Anthony Liguori5efa9d52009-05-09 17:03:42 -050026#include "module.h"
bellard585f8582006-08-05 21:14:20 +000027#include <zlib.h>
28#include "aes.h"
Kevin Wolff7d0fe02009-05-28 16:07:04 +020029#include "block/qcow2.h"
Kevin Wolfa9420732010-06-11 21:37:37 +020030#include "qemu-error.h"
Kevin Wolfe8cdcec2011-02-09 11:11:07 +010031#include "qerror.h"
bellard585f8582006-08-05 21:14:20 +000032
33/*
34 Differences with QCOW:
35
36 - Support for multiple incremental snapshots.
37 - Memory management by reference counts.
38 - Clusters which have a reference count of one have the bit
39 QCOW_OFLAG_COPIED to optimize write performance.
ths5fafdf22007-09-16 21:08:06 +000040 - Size of compressed clusters is stored in sectors to reduce bit usage
bellard585f8582006-08-05 21:14:20 +000041 in the cluster offsets.
42 - Support for storing additional data (such as the VM state) in the
ths3b46e622007-09-17 08:09:54 +000043 snapshots.
bellard585f8582006-08-05 21:14:20 +000044 - If a backing store is used, the cluster size is not constrained
45 (could be backported to QCOW).
46 - L2 tables have always a size of one cluster.
47*/
48
aliguori9b80ddf2009-03-28 17:55:06 +000049
50typedef struct {
51 uint32_t magic;
52 uint32_t len;
53} QCowExtension;
Jes Sorensen7c80ab32010-12-17 16:02:39 +010054#define QCOW2_EXT_MAGIC_END 0
55#define QCOW2_EXT_MAGIC_BACKING_FORMAT 0xE2792ACA
aliguori9b80ddf2009-03-28 17:55:06 +000056
Jes Sorensen7c80ab32010-12-17 16:02:39 +010057static int qcow2_probe(const uint8_t *buf, int buf_size, const char *filename)
bellard585f8582006-08-05 21:14:20 +000058{
59 const QCowHeader *cow_header = (const void *)buf;
ths3b46e622007-09-17 08:09:54 +000060
bellard585f8582006-08-05 21:14:20 +000061 if (buf_size >= sizeof(QCowHeader) &&
62 be32_to_cpu(cow_header->magic) == QCOW_MAGIC &&
Kevin Wolfe8cdcec2011-02-09 11:11:07 +010063 be32_to_cpu(cow_header->version) >= QCOW_VERSION)
bellard585f8582006-08-05 21:14:20 +000064 return 100;
65 else
66 return 0;
67}
68
aliguori9b80ddf2009-03-28 17:55:06 +000069
70/*
71 * read qcow2 extension and fill bs
72 * start reading from start_offset
73 * finish reading upon magic of value 0 or when end_offset reached
74 * unknown magic is skipped (future extension this version knows nothing about)
75 * return 0 upon success, non-0 otherwise
76 */
Jes Sorensen7c80ab32010-12-17 16:02:39 +010077static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
78 uint64_t end_offset)
aliguori9b80ddf2009-03-28 17:55:06 +000079{
aliguori9b80ddf2009-03-28 17:55:06 +000080 QCowExtension ext;
81 uint64_t offset;
82
83#ifdef DEBUG_EXT
Jes Sorensen7c80ab32010-12-17 16:02:39 +010084 printf("qcow2_read_extensions: start=%ld end=%ld\n", start_offset, end_offset);
aliguori9b80ddf2009-03-28 17:55:06 +000085#endif
86 offset = start_offset;
87 while (offset < end_offset) {
88
89#ifdef DEBUG_EXT
90 /* Sanity check */
91 if (offset > s->cluster_size)
Jes Sorensen7c80ab32010-12-17 16:02:39 +010092 printf("qcow2_read_extension: suspicious offset %lu\n", offset);
aliguori9b80ddf2009-03-28 17:55:06 +000093
94 printf("attemting to read extended header in offset %lu\n", offset);
95#endif
96
Kevin Wolf66f82ce2010-04-14 14:17:38 +020097 if (bdrv_pread(bs->file, offset, &ext, sizeof(ext)) != sizeof(ext)) {
Jes Sorensen7c80ab32010-12-17 16:02:39 +010098 fprintf(stderr, "qcow2_read_extension: ERROR: "
Blue Swirl0bfcd592010-05-22 08:02:12 +000099 "pread fail from offset %" PRIu64 "\n",
100 offset);
aliguori9b80ddf2009-03-28 17:55:06 +0000101 return 1;
102 }
103 be32_to_cpus(&ext.magic);
104 be32_to_cpus(&ext.len);
105 offset += sizeof(ext);
106#ifdef DEBUG_EXT
107 printf("ext.magic = 0x%x\n", ext.magic);
108#endif
109 switch (ext.magic) {
Jes Sorensen7c80ab32010-12-17 16:02:39 +0100110 case QCOW2_EXT_MAGIC_END:
aliguori9b80ddf2009-03-28 17:55:06 +0000111 return 0;
aliguorif9655092009-03-28 17:55:14 +0000112
Jes Sorensen7c80ab32010-12-17 16:02:39 +0100113 case QCOW2_EXT_MAGIC_BACKING_FORMAT:
aliguorif9655092009-03-28 17:55:14 +0000114 if (ext.len >= sizeof(bs->backing_format)) {
115 fprintf(stderr, "ERROR: ext_backing_format: len=%u too large"
aliguori4c978072009-03-29 01:31:56 +0000116 " (>=%zu)\n",
aliguorif9655092009-03-28 17:55:14 +0000117 ext.len, sizeof(bs->backing_format));
118 return 2;
119 }
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200120 if (bdrv_pread(bs->file, offset , bs->backing_format,
aliguorif9655092009-03-28 17:55:14 +0000121 ext.len) != ext.len)
122 return 3;
123 bs->backing_format[ext.len] = '\0';
124#ifdef DEBUG_EXT
125 printf("Qcow2: Got format extension %s\n", bs->backing_format);
126#endif
Kevin Wolfe1c7f0e2009-11-26 14:03:42 +0100127 offset = ((offset + ext.len + 7) & ~7);
aliguorif9655092009-03-28 17:55:14 +0000128 break;
129
aliguori9b80ddf2009-03-28 17:55:06 +0000130 default:
131 /* unknown magic -- just skip it */
Kevin Wolfe1c7f0e2009-11-26 14:03:42 +0100132 offset = ((offset + ext.len + 7) & ~7);
aliguori9b80ddf2009-03-28 17:55:06 +0000133 break;
134 }
135 }
136
137 return 0;
138}
139
140
Jes Sorensen7c80ab32010-12-17 16:02:39 +0100141static int qcow2_open(BlockDriverState *bs, int flags)
bellard585f8582006-08-05 21:14:20 +0000142{
143 BDRVQcowState *s = bs->opaque;
Jes Sorensen6d85a572010-12-17 16:02:40 +0100144 int len, i, ret = 0;
bellard585f8582006-08-05 21:14:20 +0000145 QCowHeader header;
aliguori9b80ddf2009-03-28 17:55:06 +0000146 uint64_t ext_end;
Kevin Wolf29c1a732011-01-10 17:17:28 +0100147 bool writethrough;
bellard585f8582006-08-05 21:14:20 +0000148
Jes Sorensen6d85a572010-12-17 16:02:40 +0100149 ret = bdrv_pread(bs->file, 0, &header, sizeof(header));
150 if (ret < 0) {
bellard585f8582006-08-05 21:14:20 +0000151 goto fail;
Jes Sorensen6d85a572010-12-17 16:02:40 +0100152 }
bellard585f8582006-08-05 21:14:20 +0000153 be32_to_cpus(&header.magic);
154 be32_to_cpus(&header.version);
155 be64_to_cpus(&header.backing_file_offset);
156 be32_to_cpus(&header.backing_file_size);
157 be64_to_cpus(&header.size);
158 be32_to_cpus(&header.cluster_bits);
159 be32_to_cpus(&header.crypt_method);
160 be64_to_cpus(&header.l1_table_offset);
161 be32_to_cpus(&header.l1_size);
162 be64_to_cpus(&header.refcount_table_offset);
163 be32_to_cpus(&header.refcount_table_clusters);
164 be64_to_cpus(&header.snapshots_offset);
165 be32_to_cpus(&header.nb_snapshots);
ths3b46e622007-09-17 08:09:54 +0000166
Kevin Wolfe8cdcec2011-02-09 11:11:07 +0100167 if (header.magic != QCOW_MAGIC) {
Jes Sorensen6d85a572010-12-17 16:02:40 +0100168 ret = -EINVAL;
bellard585f8582006-08-05 21:14:20 +0000169 goto fail;
Jes Sorensen6d85a572010-12-17 16:02:40 +0100170 }
Kevin Wolfe8cdcec2011-02-09 11:11:07 +0100171 if (header.version != QCOW_VERSION) {
172 char version[64];
173 snprintf(version, sizeof(version), "QCOW version %d", header.version);
174 qerror_report(QERR_UNKNOWN_BLOCK_FORMAT_FEATURE,
175 bs->device_name, "qcow2", version);
176 ret = -ENOTSUP;
177 goto fail;
178 }
Stefan Weild191d122009-10-26 16:11:16 +0100179 if (header.cluster_bits < MIN_CLUSTER_BITS ||
Jes Sorensen6d85a572010-12-17 16:02:40 +0100180 header.cluster_bits > MAX_CLUSTER_BITS) {
181 ret = -EINVAL;
bellard585f8582006-08-05 21:14:20 +0000182 goto fail;
Jes Sorensen6d85a572010-12-17 16:02:40 +0100183 }
184 if (header.crypt_method > QCOW_CRYPT_AES) {
185 ret = -EINVAL;
bellard585f8582006-08-05 21:14:20 +0000186 goto fail;
Jes Sorensen6d85a572010-12-17 16:02:40 +0100187 }
bellard585f8582006-08-05 21:14:20 +0000188 s->crypt_method_header = header.crypt_method;
Jes Sorensen6d85a572010-12-17 16:02:40 +0100189 if (s->crypt_method_header) {
bellard585f8582006-08-05 21:14:20 +0000190 bs->encrypted = 1;
Jes Sorensen6d85a572010-12-17 16:02:40 +0100191 }
bellard585f8582006-08-05 21:14:20 +0000192 s->cluster_bits = header.cluster_bits;
193 s->cluster_size = 1 << s->cluster_bits;
194 s->cluster_sectors = 1 << (s->cluster_bits - 9);
195 s->l2_bits = s->cluster_bits - 3; /* L2 is always one cluster */
196 s->l2_size = 1 << s->l2_bits;
197 bs->total_sectors = header.size / 512;
198 s->csize_shift = (62 - (s->cluster_bits - 8));
199 s->csize_mask = (1 << (s->cluster_bits - 8)) - 1;
200 s->cluster_offset_mask = (1LL << s->csize_shift) - 1;
201 s->refcount_table_offset = header.refcount_table_offset;
ths5fafdf22007-09-16 21:08:06 +0000202 s->refcount_table_size =
bellard585f8582006-08-05 21:14:20 +0000203 header.refcount_table_clusters << (s->cluster_bits - 3);
204
205 s->snapshots_offset = header.snapshots_offset;
206 s->nb_snapshots = header.nb_snapshots;
207
208 /* read the level 1 table */
209 s->l1_size = header.l1_size;
Stefan Hajnoczi419b19d2010-04-28 11:36:11 +0100210 s->l1_vm_state_index = size_to_l1(s, header.size);
bellard585f8582006-08-05 21:14:20 +0000211 /* the L1 table must contain at least enough entries to put
212 header.size bytes */
Jes Sorensen6d85a572010-12-17 16:02:40 +0100213 if (s->l1_size < s->l1_vm_state_index) {
214 ret = -EINVAL;
bellard585f8582006-08-05 21:14:20 +0000215 goto fail;
Jes Sorensen6d85a572010-12-17 16:02:40 +0100216 }
bellard585f8582006-08-05 21:14:20 +0000217 s->l1_table_offset = header.l1_table_offset;
Stefan Weild191d122009-10-26 16:11:16 +0100218 if (s->l1_size > 0) {
219 s->l1_table = qemu_mallocz(
220 align_offset(s->l1_size * sizeof(uint64_t), 512));
Jes Sorensen6d85a572010-12-17 16:02:40 +0100221 ret = bdrv_pread(bs->file, s->l1_table_offset, s->l1_table,
222 s->l1_size * sizeof(uint64_t));
223 if (ret < 0) {
Stefan Weild191d122009-10-26 16:11:16 +0100224 goto fail;
Jes Sorensen6d85a572010-12-17 16:02:40 +0100225 }
Stefan Weild191d122009-10-26 16:11:16 +0100226 for(i = 0;i < s->l1_size; i++) {
227 be64_to_cpus(&s->l1_table[i]);
228 }
bellard585f8582006-08-05 21:14:20 +0000229 }
Kevin Wolf29c1a732011-01-10 17:17:28 +0100230
231 /* alloc L2 table/refcount block cache */
Christoph Hellwiga6599792011-05-17 18:04:06 +0200232 writethrough = ((flags & BDRV_O_CACHE_WB) == 0);
Kevin Wolf29c1a732011-01-10 17:17:28 +0100233 s->l2_table_cache = qcow2_cache_create(bs, L2_CACHE_SIZE, writethrough);
234 s->refcount_block_cache = qcow2_cache_create(bs, REFCOUNT_CACHE_SIZE,
235 writethrough);
236
bellard585f8582006-08-05 21:14:20 +0000237 s->cluster_cache = qemu_malloc(s->cluster_size);
bellard585f8582006-08-05 21:14:20 +0000238 /* one more sector for decompressed data alignment */
aliguori095a9c52008-08-14 18:10:28 +0000239 s->cluster_data = qemu_malloc(QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size
240 + 512);
bellard585f8582006-08-05 21:14:20 +0000241 s->cluster_cache_offset = -1;
ths3b46e622007-09-17 08:09:54 +0000242
Jes Sorensen6d85a572010-12-17 16:02:40 +0100243 ret = qcow2_refcount_init(bs);
244 if (ret != 0) {
bellard585f8582006-08-05 21:14:20 +0000245 goto fail;
Jes Sorensen6d85a572010-12-17 16:02:40 +0100246 }
bellard585f8582006-08-05 21:14:20 +0000247
Blue Swirl72cf2d42009-09-12 07:36:22 +0000248 QLIST_INIT(&s->cluster_allocs);
Kevin Wolff2149782009-08-31 16:48:49 +0200249
aliguori9b80ddf2009-03-28 17:55:06 +0000250 /* read qcow2 extensions */
Jes Sorensen6d85a572010-12-17 16:02:40 +0100251 if (header.backing_file_offset) {
aliguori9b80ddf2009-03-28 17:55:06 +0000252 ext_end = header.backing_file_offset;
Jes Sorensen6d85a572010-12-17 16:02:40 +0100253 } else {
aliguori9b80ddf2009-03-28 17:55:06 +0000254 ext_end = s->cluster_size;
Jes Sorensen6d85a572010-12-17 16:02:40 +0100255 }
256 if (qcow2_read_extensions(bs, sizeof(header), ext_end)) {
257 ret = -EINVAL;
aliguori9b80ddf2009-03-28 17:55:06 +0000258 goto fail;
Jes Sorensen6d85a572010-12-17 16:02:40 +0100259 }
aliguori9b80ddf2009-03-28 17:55:06 +0000260
bellard585f8582006-08-05 21:14:20 +0000261 /* read the backing file name */
262 if (header.backing_file_offset != 0) {
263 len = header.backing_file_size;
Jes Sorensen6d85a572010-12-17 16:02:40 +0100264 if (len > 1023) {
bellard585f8582006-08-05 21:14:20 +0000265 len = 1023;
Jes Sorensen6d85a572010-12-17 16:02:40 +0100266 }
267 ret = bdrv_pread(bs->file, header.backing_file_offset,
268 bs->backing_file, len);
269 if (ret < 0) {
bellard585f8582006-08-05 21:14:20 +0000270 goto fail;
Jes Sorensen6d85a572010-12-17 16:02:40 +0100271 }
bellard585f8582006-08-05 21:14:20 +0000272 bs->backing_file[len] = '\0';
273 }
Jes Sorensen6d85a572010-12-17 16:02:40 +0100274 if (qcow2_read_snapshots(bs) < 0) {
275 ret = -EINVAL;
bellard585f8582006-08-05 21:14:20 +0000276 goto fail;
Jes Sorensen6d85a572010-12-17 16:02:40 +0100277 }
bellard585f8582006-08-05 21:14:20 +0000278
279#ifdef DEBUG_ALLOC
Filip Navara14899cd2009-06-23 19:17:30 -0500280 qcow2_check_refcounts(bs);
bellard585f8582006-08-05 21:14:20 +0000281#endif
Jes Sorensen6d85a572010-12-17 16:02:40 +0100282 return ret;
bellard585f8582006-08-05 21:14:20 +0000283
284 fail:
Kevin Wolfed6ccf02009-05-28 16:07:07 +0200285 qcow2_free_snapshots(bs);
286 qcow2_refcount_close(bs);
bellard585f8582006-08-05 21:14:20 +0000287 qemu_free(s->l1_table);
Kevin Wolf29c1a732011-01-10 17:17:28 +0100288 if (s->l2_table_cache) {
289 qcow2_cache_destroy(bs, s->l2_table_cache);
290 }
bellard585f8582006-08-05 21:14:20 +0000291 qemu_free(s->cluster_cache);
292 qemu_free(s->cluster_data);
Jes Sorensen6d85a572010-12-17 16:02:40 +0100293 return ret;
bellard585f8582006-08-05 21:14:20 +0000294}
295
Jes Sorensen7c80ab32010-12-17 16:02:39 +0100296static int qcow2_set_key(BlockDriverState *bs, const char *key)
bellard585f8582006-08-05 21:14:20 +0000297{
298 BDRVQcowState *s = bs->opaque;
299 uint8_t keybuf[16];
300 int len, i;
ths3b46e622007-09-17 08:09:54 +0000301
bellard585f8582006-08-05 21:14:20 +0000302 memset(keybuf, 0, 16);
303 len = strlen(key);
304 if (len > 16)
305 len = 16;
306 /* XXX: we could compress the chars to 7 bits to increase
307 entropy */
308 for(i = 0;i < len;i++) {
309 keybuf[i] = key[i];
310 }
311 s->crypt_method = s->crypt_method_header;
312
313 if (AES_set_encrypt_key(keybuf, 128, &s->aes_encrypt_key) != 0)
314 return -1;
315 if (AES_set_decrypt_key(keybuf, 128, &s->aes_decrypt_key) != 0)
316 return -1;
317#if 0
318 /* test */
319 {
320 uint8_t in[16];
321 uint8_t out[16];
322 uint8_t tmp[16];
323 for(i=0;i<16;i++)
324 in[i] = i;
325 AES_encrypt(in, tmp, &s->aes_encrypt_key);
326 AES_decrypt(tmp, out, &s->aes_decrypt_key);
327 for(i = 0; i < 16; i++)
328 printf(" %02x", tmp[i]);
329 printf("\n");
330 for(i = 0; i < 16; i++)
331 printf(" %02x", out[i]);
332 printf("\n");
333 }
334#endif
335 return 0;
336}
337
Jes Sorensen7c80ab32010-12-17 16:02:39 +0100338static int qcow2_is_allocated(BlockDriverState *bs, int64_t sector_num,
339 int nb_sectors, int *pnum)
bellard585f8582006-08-05 21:14:20 +0000340{
bellard585f8582006-08-05 21:14:20 +0000341 uint64_t cluster_offset;
Kevin Wolf1c46efa2010-05-21 17:59:36 +0200342 int ret;
bellard585f8582006-08-05 21:14:20 +0000343
aliguori095a9c52008-08-14 18:10:28 +0000344 *pnum = nb_sectors;
Kevin Wolf1c46efa2010-05-21 17:59:36 +0200345 /* FIXME We can get errors here, but the bdrv_is_allocated interface can't
346 * pass them on today */
347 ret = qcow2_get_cluster_offset(bs, sector_num << 9, pnum, &cluster_offset);
348 if (ret < 0) {
349 *pnum = 0;
350 }
aliguori095a9c52008-08-14 18:10:28 +0000351
bellard585f8582006-08-05 21:14:20 +0000352 return (cluster_offset != 0);
353}
354
bellarda9465922006-08-06 13:34:04 +0000355/* handle reading after the end of the backing file */
Kevin Wolfbd28f832010-09-13 18:08:52 +0200356int qcow2_backing_read1(BlockDriverState *bs, QEMUIOVector *qiov,
357 int64_t sector_num, int nb_sectors)
bellarda9465922006-08-06 13:34:04 +0000358{
359 int n1;
360 if ((sector_num + nb_sectors) <= bs->total_sectors)
361 return nb_sectors;
362 if (sector_num >= bs->total_sectors)
363 n1 = 0;
364 else
365 n1 = bs->total_sectors - sector_num;
Kevin Wolfbd28f832010-09-13 18:08:52 +0200366
Chunqiang Tange0d9c6f2011-02-03 10:12:49 -0500367 qemu_iovec_memset_skip(qiov, 0, 512 * (nb_sectors - n1), 512 * n1);
Kevin Wolfbd28f832010-09-13 18:08:52 +0200368
bellarda9465922006-08-06 13:34:04 +0000369 return n1;
370}
371
pbrookce1a14d2006-08-07 02:38:06 +0000372typedef struct QCowAIOCB {
373 BlockDriverAIOCB common;
bellard585f8582006-08-05 21:14:20 +0000374 int64_t sector_num;
aliguorif141eaf2009-04-07 18:43:24 +0000375 QEMUIOVector *qiov;
Christoph Hellwig7b88e482010-01-21 16:12:09 +0100376 int remaining_sectors;
377 int cur_nr_sectors; /* number of sectors in current iteration */
Kevin Wolfbd28f832010-09-13 18:08:52 +0200378 uint64_t bytes_done;
bellard585f8582006-08-05 21:14:20 +0000379 uint64_t cluster_offset;
ths5fafdf22007-09-16 21:08:06 +0000380 uint8_t *cluster_data;
Kevin Wolf42496d62011-06-07 15:04:32 +0200381 bool is_write;
bellard585f8582006-08-05 21:14:20 +0000382 BlockDriverAIOCB *hd_aiocb;
aliguoric87c0672009-04-07 18:43:20 +0000383 QEMUIOVector hd_qiov;
aliguori14907912008-10-31 17:28:00 +0000384 QEMUBH *bh;
aliguorie976c6a2008-12-02 20:14:05 +0000385 QCowL2Meta l2meta;
Blue Swirl72cf2d42009-09-12 07:36:22 +0000386 QLIST_ENTRY(QCowAIOCB) next_depend;
bellard585f8582006-08-05 21:14:20 +0000387} QCowAIOCB;
388
Jes Sorensen7c80ab32010-12-17 16:02:39 +0100389static void qcow2_aio_cancel(BlockDriverAIOCB *blockacb)
Christoph Hellwigc16b5a22009-05-25 12:37:32 +0200390{
Kevin Wolfb666d232010-05-05 11:44:39 +0200391 QCowAIOCB *acb = container_of(blockacb, QCowAIOCB, common);
Christoph Hellwigc16b5a22009-05-25 12:37:32 +0200392 if (acb->hd_aiocb)
393 bdrv_aio_cancel(acb->hd_aiocb);
394 qemu_aio_release(acb);
395}
396
Jes Sorensen7c80ab32010-12-17 16:02:39 +0100397static AIOPool qcow2_aio_pool = {
Christoph Hellwigc16b5a22009-05-25 12:37:32 +0200398 .aiocb_size = sizeof(QCowAIOCB),
Jes Sorensen7c80ab32010-12-17 16:02:39 +0100399 .cancel = qcow2_aio_cancel,
Christoph Hellwigc16b5a22009-05-25 12:37:32 +0200400};
401
Jes Sorensen7c80ab32010-12-17 16:02:39 +0100402static void qcow2_aio_read_cb(void *opaque, int ret);
Kevin Wolf42496d62011-06-07 15:04:32 +0200403static void qcow2_aio_write_cb(void *opaque, int ret);
404
405static void qcow2_aio_rw_bh(void *opaque)
aliguori14907912008-10-31 17:28:00 +0000406{
407 QCowAIOCB *acb = opaque;
408 qemu_bh_delete(acb->bh);
409 acb->bh = NULL;
Kevin Wolf42496d62011-06-07 15:04:32 +0200410
411 if (acb->is_write) {
412 qcow2_aio_write_cb(opaque, 0);
413 } else {
414 qcow2_aio_read_cb(opaque, 0);
415 }
aliguori14907912008-10-31 17:28:00 +0000416}
417
Jes Sorensen7c80ab32010-12-17 16:02:39 +0100418static int qcow2_schedule_bh(QEMUBHFunc *cb, QCowAIOCB *acb)
aliguoria32ef782008-12-02 20:08:04 +0000419{
420 if (acb->bh)
421 return -EIO;
422
423 acb->bh = qemu_bh_new(cb, acb);
424 if (!acb->bh)
425 return -EIO;
426
427 qemu_bh_schedule(acb->bh);
428
429 return 0;
430}
431
Jes Sorensen7c80ab32010-12-17 16:02:39 +0100432static void qcow2_aio_read_cb(void *opaque, int ret)
bellard585f8582006-08-05 21:14:20 +0000433{
pbrookce1a14d2006-08-07 02:38:06 +0000434 QCowAIOCB *acb = opaque;
435 BlockDriverState *bs = acb->common.bs;
bellard585f8582006-08-05 21:14:20 +0000436 BDRVQcowState *s = bs->opaque;
bellarda9465922006-08-06 13:34:04 +0000437 int index_in_cluster, n1;
bellard585f8582006-08-05 21:14:20 +0000438
pbrookce1a14d2006-08-07 02:38:06 +0000439 acb->hd_aiocb = NULL;
aliguorif141eaf2009-04-07 18:43:24 +0000440 if (ret < 0)
441 goto done;
bellard585f8582006-08-05 21:14:20 +0000442
bellard585f8582006-08-05 21:14:20 +0000443 /* post process the read buffer */
pbrookce1a14d2006-08-07 02:38:06 +0000444 if (!acb->cluster_offset) {
bellard585f8582006-08-05 21:14:20 +0000445 /* nothing to do */
pbrookce1a14d2006-08-07 02:38:06 +0000446 } else if (acb->cluster_offset & QCOW_OFLAG_COMPRESSED) {
bellard585f8582006-08-05 21:14:20 +0000447 /* nothing to do */
448 } else {
449 if (s->crypt_method) {
Kevin Wolfbd28f832010-09-13 18:08:52 +0200450 qcow2_encrypt_sectors(s, acb->sector_num, acb->cluster_data,
451 acb->cluster_data, acb->cur_nr_sectors, 0, &s->aes_decrypt_key);
452 qemu_iovec_reset(&acb->hd_qiov);
453 qemu_iovec_copy(&acb->hd_qiov, acb->qiov, acb->bytes_done,
454 acb->cur_nr_sectors * 512);
455 qemu_iovec_from_buffer(&acb->hd_qiov, acb->cluster_data,
456 512 * acb->cur_nr_sectors);
bellard585f8582006-08-05 21:14:20 +0000457 }
458 }
459
Christoph Hellwig7b88e482010-01-21 16:12:09 +0100460 acb->remaining_sectors -= acb->cur_nr_sectors;
461 acb->sector_num += acb->cur_nr_sectors;
Kevin Wolfbd28f832010-09-13 18:08:52 +0200462 acb->bytes_done += acb->cur_nr_sectors * 512;
bellard585f8582006-08-05 21:14:20 +0000463
Christoph Hellwig7b88e482010-01-21 16:12:09 +0100464 if (acb->remaining_sectors == 0) {
bellard585f8582006-08-05 21:14:20 +0000465 /* request completed */
aliguorif141eaf2009-04-07 18:43:24 +0000466 ret = 0;
467 goto done;
bellard585f8582006-08-05 21:14:20 +0000468 }
ths3b46e622007-09-17 08:09:54 +0000469
bellard585f8582006-08-05 21:14:20 +0000470 /* prepare next AIO request */
Christoph Hellwig7b88e482010-01-21 16:12:09 +0100471 acb->cur_nr_sectors = acb->remaining_sectors;
Kevin Wolfbd28f832010-09-13 18:08:52 +0200472 if (s->crypt_method) {
473 acb->cur_nr_sectors = MIN(acb->cur_nr_sectors,
474 QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors);
475 }
476
Kevin Wolf1c46efa2010-05-21 17:59:36 +0200477 ret = qcow2_get_cluster_offset(bs, acb->sector_num << 9,
478 &acb->cur_nr_sectors, &acb->cluster_offset);
479 if (ret < 0) {
480 goto done;
481 }
482
pbrookce1a14d2006-08-07 02:38:06 +0000483 index_in_cluster = acb->sector_num & (s->cluster_sectors - 1);
bellard585f8582006-08-05 21:14:20 +0000484
Kevin Wolfbd28f832010-09-13 18:08:52 +0200485 qemu_iovec_reset(&acb->hd_qiov);
486 qemu_iovec_copy(&acb->hd_qiov, acb->qiov, acb->bytes_done,
487 acb->cur_nr_sectors * 512);
488
pbrookce1a14d2006-08-07 02:38:06 +0000489 if (!acb->cluster_offset) {
Kevin Wolfbd28f832010-09-13 18:08:52 +0200490
bellard585f8582006-08-05 21:14:20 +0000491 if (bs->backing_hd) {
492 /* read from the base image */
Kevin Wolfbd28f832010-09-13 18:08:52 +0200493 n1 = qcow2_backing_read1(bs->backing_hd, &acb->hd_qiov,
494 acb->sector_num, acb->cur_nr_sectors);
bellarda9465922006-08-06 13:34:04 +0000495 if (n1 > 0) {
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200496 BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
aliguoric87c0672009-04-07 18:43:20 +0000497 acb->hd_aiocb = bdrv_aio_readv(bs->backing_hd, acb->sector_num,
Chunqiang Tange0d9c6f2011-02-03 10:12:49 -0500498 &acb->hd_qiov, n1, qcow2_aio_read_cb, acb);
Kevin Wolf3ab4c7e2011-02-08 18:12:35 +0100499 if (acb->hd_aiocb == NULL) {
500 ret = -EIO;
aliguorif141eaf2009-04-07 18:43:24 +0000501 goto done;
Kevin Wolf3ab4c7e2011-02-08 18:12:35 +0100502 }
bellarda9465922006-08-06 13:34:04 +0000503 } else {
Kevin Wolf42496d62011-06-07 15:04:32 +0200504 ret = qcow2_schedule_bh(qcow2_aio_rw_bh, acb);
aliguoria32ef782008-12-02 20:08:04 +0000505 if (ret < 0)
aliguorif141eaf2009-04-07 18:43:24 +0000506 goto done;
bellarda9465922006-08-06 13:34:04 +0000507 }
bellard585f8582006-08-05 21:14:20 +0000508 } else {
509 /* Note: in this case, no need to wait */
Kevin Wolfbd28f832010-09-13 18:08:52 +0200510 qemu_iovec_memset(&acb->hd_qiov, 0, 512 * acb->cur_nr_sectors);
Kevin Wolf42496d62011-06-07 15:04:32 +0200511 ret = qcow2_schedule_bh(qcow2_aio_rw_bh, acb);
aliguoria32ef782008-12-02 20:08:04 +0000512 if (ret < 0)
aliguorif141eaf2009-04-07 18:43:24 +0000513 goto done;
bellard585f8582006-08-05 21:14:20 +0000514 }
pbrookce1a14d2006-08-07 02:38:06 +0000515 } else if (acb->cluster_offset & QCOW_OFLAG_COMPRESSED) {
bellard585f8582006-08-05 21:14:20 +0000516 /* add AIO support for compressed blocks ? */
Kevin Wolf8af36482011-02-09 10:26:06 +0100517 ret = qcow2_decompress_cluster(bs, acb->cluster_offset);
518 if (ret < 0) {
aliguorif141eaf2009-04-07 18:43:24 +0000519 goto done;
Kevin Wolf8af36482011-02-09 10:26:06 +0100520 }
Kevin Wolfbd28f832010-09-13 18:08:52 +0200521
522 qemu_iovec_from_buffer(&acb->hd_qiov,
523 s->cluster_cache + index_in_cluster * 512,
524 512 * acb->cur_nr_sectors);
525
Kevin Wolf42496d62011-06-07 15:04:32 +0200526 ret = qcow2_schedule_bh(qcow2_aio_rw_bh, acb);
aliguoria32ef782008-12-02 20:08:04 +0000527 if (ret < 0)
aliguorif141eaf2009-04-07 18:43:24 +0000528 goto done;
bellard585f8582006-08-05 21:14:20 +0000529 } else {
pbrookce1a14d2006-08-07 02:38:06 +0000530 if ((acb->cluster_offset & 511) != 0) {
bellard585f8582006-08-05 21:14:20 +0000531 ret = -EIO;
aliguorif141eaf2009-04-07 18:43:24 +0000532 goto done;
bellard585f8582006-08-05 21:14:20 +0000533 }
aliguoric87c0672009-04-07 18:43:20 +0000534
Kevin Wolfbd28f832010-09-13 18:08:52 +0200535 if (s->crypt_method) {
536 /*
537 * For encrypted images, read everything into a temporary
538 * contiguous buffer on which the AES functions can work.
539 */
540 if (!acb->cluster_data) {
541 acb->cluster_data =
542 qemu_mallocz(QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);
543 }
544
545 assert(acb->cur_nr_sectors <=
546 QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors);
547 qemu_iovec_reset(&acb->hd_qiov);
548 qemu_iovec_add(&acb->hd_qiov, acb->cluster_data,
549 512 * acb->cur_nr_sectors);
550 }
551
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200552 BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
553 acb->hd_aiocb = bdrv_aio_readv(bs->file,
ths5fafdf22007-09-16 21:08:06 +0000554 (acb->cluster_offset >> 9) + index_in_cluster,
Christoph Hellwig7b88e482010-01-21 16:12:09 +0100555 &acb->hd_qiov, acb->cur_nr_sectors,
Jes Sorensen7c80ab32010-12-17 16:02:39 +0100556 qcow2_aio_read_cb, acb);
Kevin Wolf171e3d62010-04-06 15:30:09 +0200557 if (acb->hd_aiocb == NULL) {
558 ret = -EIO;
aliguorif141eaf2009-04-07 18:43:24 +0000559 goto done;
Kevin Wolf171e3d62010-04-06 15:30:09 +0200560 }
bellard585f8582006-08-05 21:14:20 +0000561 }
aliguorif141eaf2009-04-07 18:43:24 +0000562
563 return;
564done:
aliguorif141eaf2009-04-07 18:43:24 +0000565 acb->common.cb(acb->common.opaque, ret);
Kevin Wolfbd28f832010-09-13 18:08:52 +0200566 qemu_iovec_destroy(&acb->hd_qiov);
aliguorif141eaf2009-04-07 18:43:24 +0000567 qemu_aio_release(acb);
bellard585f8582006-08-05 21:14:20 +0000568}
569
Jes Sorensen7c80ab32010-12-17 16:02:39 +0100570static QCowAIOCB *qcow2_aio_setup(BlockDriverState *bs, int64_t sector_num,
571 QEMUIOVector *qiov, int nb_sectors,
572 BlockDriverCompletionFunc *cb,
573 void *opaque, int is_write)
bellard585f8582006-08-05 21:14:20 +0000574{
pbrookce1a14d2006-08-07 02:38:06 +0000575 QCowAIOCB *acb;
576
Jes Sorensen7c80ab32010-12-17 16:02:39 +0100577 acb = qemu_aio_get(&qcow2_aio_pool, bs, cb, opaque);
pbrookce1a14d2006-08-07 02:38:06 +0000578 if (!acb)
579 return NULL;
580 acb->hd_aiocb = NULL;
581 acb->sector_num = sector_num;
aliguorif141eaf2009-04-07 18:43:24 +0000582 acb->qiov = qiov;
Kevin Wolf42496d62011-06-07 15:04:32 +0200583 acb->is_write = is_write;
Kevin Wolfbd28f832010-09-13 18:08:52 +0200584
Kevin Wolf6f5f0602010-09-13 18:24:10 +0200585 qemu_iovec_init(&acb->hd_qiov, qiov->niov);
Kevin Wolfbd28f832010-09-13 18:08:52 +0200586
587 acb->bytes_done = 0;
Christoph Hellwig7b88e482010-01-21 16:12:09 +0100588 acb->remaining_sectors = nb_sectors;
589 acb->cur_nr_sectors = 0;
pbrookce1a14d2006-08-07 02:38:06 +0000590 acb->cluster_offset = 0;
aliguorie976c6a2008-12-02 20:14:05 +0000591 acb->l2meta.nb_clusters = 0;
Blue Swirl72cf2d42009-09-12 07:36:22 +0000592 QLIST_INIT(&acb->l2meta.dependent_requests);
pbrookce1a14d2006-08-07 02:38:06 +0000593 return acb;
594}
595
Jes Sorensen7c80ab32010-12-17 16:02:39 +0100596static BlockDriverAIOCB *qcow2_aio_readv(BlockDriverState *bs,
597 int64_t sector_num,
598 QEMUIOVector *qiov, int nb_sectors,
599 BlockDriverCompletionFunc *cb,
600 void *opaque)
pbrookce1a14d2006-08-07 02:38:06 +0000601{
602 QCowAIOCB *acb;
Kevin Wolf42496d62011-06-07 15:04:32 +0200603 int ret;
pbrookce1a14d2006-08-07 02:38:06 +0000604
Jes Sorensen7c80ab32010-12-17 16:02:39 +0100605 acb = qcow2_aio_setup(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
pbrookce1a14d2006-08-07 02:38:06 +0000606 if (!acb)
607 return NULL;
bellard585f8582006-08-05 21:14:20 +0000608
Kevin Wolf42496d62011-06-07 15:04:32 +0200609 ret = qcow2_schedule_bh(qcow2_aio_rw_bh, acb);
610 if (ret < 0) {
611 qemu_iovec_destroy(&acb->hd_qiov);
612 qemu_aio_release(acb);
613 return NULL;
614 }
615
pbrookce1a14d2006-08-07 02:38:06 +0000616 return &acb->common;
bellard585f8582006-08-05 21:14:20 +0000617}
618
Kevin Wolff2149782009-08-31 16:48:49 +0200619static void run_dependent_requests(QCowL2Meta *m)
620{
621 QCowAIOCB *req;
622 QCowAIOCB *next;
623
624 /* Take the request off the list of running requests */
625 if (m->nb_clusters != 0) {
Blue Swirl72cf2d42009-09-12 07:36:22 +0000626 QLIST_REMOVE(m, next_in_flight);
Kevin Wolff2149782009-08-31 16:48:49 +0200627 }
628
Stefan Hajnoczid4c146f2010-04-15 14:11:35 +0100629 /* Restart all dependent requests */
630 QLIST_FOREACH_SAFE(req, &m->dependent_requests, next_depend, next) {
Jes Sorensen7c80ab32010-12-17 16:02:39 +0100631 qcow2_aio_write_cb(req, 0);
Kevin Wolff2149782009-08-31 16:48:49 +0200632 }
633
634 /* Empty the list for the next part of the request */
Blue Swirl72cf2d42009-09-12 07:36:22 +0000635 QLIST_INIT(&m->dependent_requests);
Kevin Wolff2149782009-08-31 16:48:49 +0200636}
637
Jes Sorensen7c80ab32010-12-17 16:02:39 +0100638static void qcow2_aio_write_cb(void *opaque, int ret)
bellard585f8582006-08-05 21:14:20 +0000639{
pbrookce1a14d2006-08-07 02:38:06 +0000640 QCowAIOCB *acb = opaque;
641 BlockDriverState *bs = acb->common.bs;
bellard585f8582006-08-05 21:14:20 +0000642 BDRVQcowState *s = bs->opaque;
bellard585f8582006-08-05 21:14:20 +0000643 int index_in_cluster;
aliguori095a9c52008-08-14 18:10:28 +0000644 int n_end;
pbrookce1a14d2006-08-07 02:38:06 +0000645
646 acb->hd_aiocb = NULL;
647
Kevin Wolff2149782009-08-31 16:48:49 +0200648 if (ret >= 0) {
Kevin Wolf148da7e2010-01-20 15:03:01 +0100649 ret = qcow2_alloc_cluster_link_l2(bs, &acb->l2meta);
Kevin Wolff2149782009-08-31 16:48:49 +0200650 }
651
652 run_dependent_requests(&acb->l2meta);
653
aliguorif141eaf2009-04-07 18:43:24 +0000654 if (ret < 0)
655 goto done;
bellard585f8582006-08-05 21:14:20 +0000656
Christoph Hellwig7b88e482010-01-21 16:12:09 +0100657 acb->remaining_sectors -= acb->cur_nr_sectors;
658 acb->sector_num += acb->cur_nr_sectors;
Kevin Wolf6f5f0602010-09-13 18:24:10 +0200659 acb->bytes_done += acb->cur_nr_sectors * 512;
bellard585f8582006-08-05 21:14:20 +0000660
Christoph Hellwig7b88e482010-01-21 16:12:09 +0100661 if (acb->remaining_sectors == 0) {
bellard585f8582006-08-05 21:14:20 +0000662 /* request completed */
aliguorif141eaf2009-04-07 18:43:24 +0000663 ret = 0;
664 goto done;
bellard585f8582006-08-05 21:14:20 +0000665 }
ths3b46e622007-09-17 08:09:54 +0000666
pbrookce1a14d2006-08-07 02:38:06 +0000667 index_in_cluster = acb->sector_num & (s->cluster_sectors - 1);
Christoph Hellwig7b88e482010-01-21 16:12:09 +0100668 n_end = index_in_cluster + acb->remaining_sectors;
aliguori095a9c52008-08-14 18:10:28 +0000669 if (s->crypt_method &&
670 n_end > QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors)
671 n_end = QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors;
672
Kevin Wolf148da7e2010-01-20 15:03:01 +0100673 ret = qcow2_alloc_cluster_offset(bs, acb->sector_num << 9,
Christoph Hellwig7b88e482010-01-21 16:12:09 +0100674 index_in_cluster, n_end, &acb->cur_nr_sectors, &acb->l2meta);
Kevin Wolf148da7e2010-01-20 15:03:01 +0100675 if (ret < 0) {
676 goto done;
677 }
678
679 acb->cluster_offset = acb->l2meta.cluster_offset;
Kevin Wolff2149782009-08-31 16:48:49 +0200680
681 /* Need to wait for another request? If so, we are done for now. */
Kevin Wolf148da7e2010-01-20 15:03:01 +0100682 if (acb->l2meta.nb_clusters == 0 && acb->l2meta.depends_on != NULL) {
Blue Swirl72cf2d42009-09-12 07:36:22 +0000683 QLIST_INSERT_HEAD(&acb->l2meta.depends_on->dependent_requests,
Kevin Wolff2149782009-08-31 16:48:49 +0200684 acb, next_depend);
685 return;
686 }
687
Kevin Wolf148da7e2010-01-20 15:03:01 +0100688 assert((acb->cluster_offset & 511) == 0);
689
Kevin Wolf6f5f0602010-09-13 18:24:10 +0200690 qemu_iovec_reset(&acb->hd_qiov);
691 qemu_iovec_copy(&acb->hd_qiov, acb->qiov, acb->bytes_done,
692 acb->cur_nr_sectors * 512);
693
bellard585f8582006-08-05 21:14:20 +0000694 if (s->crypt_method) {
pbrookce1a14d2006-08-07 02:38:06 +0000695 if (!acb->cluster_data) {
aliguori095a9c52008-08-14 18:10:28 +0000696 acb->cluster_data = qemu_mallocz(QCOW_MAX_CRYPT_CLUSTERS *
697 s->cluster_size);
bellard585f8582006-08-05 21:14:20 +0000698 }
Kevin Wolf6f5f0602010-09-13 18:24:10 +0200699
700 assert(acb->hd_qiov.size <= QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);
701 qemu_iovec_to_buffer(&acb->hd_qiov, acb->cluster_data);
702
703 qcow2_encrypt_sectors(s, acb->sector_num, acb->cluster_data,
704 acb->cluster_data, acb->cur_nr_sectors, 1, &s->aes_encrypt_key);
705
706 qemu_iovec_reset(&acb->hd_qiov);
707 qemu_iovec_add(&acb->hd_qiov, acb->cluster_data,
708 acb->cur_nr_sectors * 512);
bellard585f8582006-08-05 21:14:20 +0000709 }
Kevin Wolf6f5f0602010-09-13 18:24:10 +0200710
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200711 BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
712 acb->hd_aiocb = bdrv_aio_writev(bs->file,
aliguoric87c0672009-04-07 18:43:20 +0000713 (acb->cluster_offset >> 9) + index_in_cluster,
Christoph Hellwig7b88e482010-01-21 16:12:09 +0100714 &acb->hd_qiov, acb->cur_nr_sectors,
Jes Sorensen7c80ab32010-12-17 16:02:39 +0100715 qcow2_aio_write_cb, acb);
Kevin Wolf171e3d62010-04-06 15:30:09 +0200716 if (acb->hd_aiocb == NULL) {
717 ret = -EIO;
Kevin Wolfc644db32010-04-06 15:30:14 +0200718 goto fail;
Kevin Wolf171e3d62010-04-06 15:30:09 +0200719 }
aliguorif141eaf2009-04-07 18:43:24 +0000720
721 return;
722
Kevin Wolfc644db32010-04-06 15:30:14 +0200723fail:
724 if (acb->l2meta.nb_clusters != 0) {
725 QLIST_REMOVE(&acb->l2meta, next_in_flight);
726 }
aliguorif141eaf2009-04-07 18:43:24 +0000727done:
aliguorif141eaf2009-04-07 18:43:24 +0000728 acb->common.cb(acb->common.opaque, ret);
Kevin Wolf6f5f0602010-09-13 18:24:10 +0200729 qemu_iovec_destroy(&acb->hd_qiov);
aliguorif141eaf2009-04-07 18:43:24 +0000730 qemu_aio_release(acb);
bellard585f8582006-08-05 21:14:20 +0000731}
732
Jes Sorensen7c80ab32010-12-17 16:02:39 +0100733static BlockDriverAIOCB *qcow2_aio_writev(BlockDriverState *bs,
734 int64_t sector_num,
735 QEMUIOVector *qiov, int nb_sectors,
736 BlockDriverCompletionFunc *cb,
737 void *opaque)
bellard585f8582006-08-05 21:14:20 +0000738{
bellard585f8582006-08-05 21:14:20 +0000739 BDRVQcowState *s = bs->opaque;
pbrookce1a14d2006-08-07 02:38:06 +0000740 QCowAIOCB *acb;
Kevin Wolf42496d62011-06-07 15:04:32 +0200741 int ret;
ths3b46e622007-09-17 08:09:54 +0000742
bellard585f8582006-08-05 21:14:20 +0000743 s->cluster_cache_offset = -1; /* disable compressed cache */
744
Jes Sorensen7c80ab32010-12-17 16:02:39 +0100745 acb = qcow2_aio_setup(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
pbrookce1a14d2006-08-07 02:38:06 +0000746 if (!acb)
747 return NULL;
ths3b46e622007-09-17 08:09:54 +0000748
Kevin Wolf42496d62011-06-07 15:04:32 +0200749 ret = qcow2_schedule_bh(qcow2_aio_rw_bh, acb);
750 if (ret < 0) {
751 qemu_iovec_destroy(&acb->hd_qiov);
752 qemu_aio_release(acb);
753 return NULL;
754 }
755
pbrookce1a14d2006-08-07 02:38:06 +0000756 return &acb->common;
bellard585f8582006-08-05 21:14:20 +0000757}
758
Jes Sorensen7c80ab32010-12-17 16:02:39 +0100759static void qcow2_close(BlockDriverState *bs)
bellard585f8582006-08-05 21:14:20 +0000760{
761 BDRVQcowState *s = bs->opaque;
762 qemu_free(s->l1_table);
Kevin Wolf29c1a732011-01-10 17:17:28 +0100763
764 qcow2_cache_flush(bs, s->l2_table_cache);
765 qcow2_cache_flush(bs, s->refcount_block_cache);
766
767 qcow2_cache_destroy(bs, s->l2_table_cache);
768 qcow2_cache_destroy(bs, s->refcount_block_cache);
769
bellard585f8582006-08-05 21:14:20 +0000770 qemu_free(s->cluster_cache);
771 qemu_free(s->cluster_data);
Kevin Wolfed6ccf02009-05-28 16:07:07 +0200772 qcow2_refcount_close(bs);
bellard585f8582006-08-05 21:14:20 +0000773}
774
Kevin Wolf756e6732010-01-12 12:55:17 +0100775/*
776 * Updates the variable length parts of the qcow2 header, i.e. the backing file
777 * name and all extensions. qcow2 was not designed to allow such changes, so if
778 * we run out of space (we can only use the first cluster) this function may
779 * fail.
780 *
781 * Returns 0 on success, -errno in error cases.
782 */
783static int qcow2_update_ext_header(BlockDriverState *bs,
784 const char *backing_file, const char *backing_fmt)
785{
786 size_t backing_file_len = 0;
787 size_t backing_fmt_len = 0;
788 BDRVQcowState *s = bs->opaque;
789 QCowExtension ext_backing_fmt = {0, 0};
790 int ret;
791
792 /* Backing file format doesn't make sense without a backing file */
793 if (backing_fmt && !backing_file) {
794 return -EINVAL;
795 }
796
797 /* Prepare the backing file format extension if needed */
798 if (backing_fmt) {
799 ext_backing_fmt.len = cpu_to_be32(strlen(backing_fmt));
Jes Sorensen7c80ab32010-12-17 16:02:39 +0100800 ext_backing_fmt.magic = cpu_to_be32(QCOW2_EXT_MAGIC_BACKING_FORMAT);
Kevin Wolf756e6732010-01-12 12:55:17 +0100801 backing_fmt_len = ((sizeof(ext_backing_fmt)
802 + strlen(backing_fmt) + 7) & ~7);
803 }
804
805 /* Check if we can fit the new header into the first cluster */
806 if (backing_file) {
807 backing_file_len = strlen(backing_file);
808 }
809
810 size_t header_size = sizeof(QCowHeader) + backing_file_len
811 + backing_fmt_len;
812
813 if (header_size > s->cluster_size) {
814 return -ENOSPC;
815 }
816
817 /* Rewrite backing file name and qcow2 extensions */
818 size_t ext_size = header_size - sizeof(QCowHeader);
819 uint8_t buf[ext_size];
820 size_t offset = 0;
821 size_t backing_file_offset = 0;
822
823 if (backing_file) {
824 if (backing_fmt) {
825 int padding = backing_fmt_len -
826 (sizeof(ext_backing_fmt) + strlen(backing_fmt));
827
828 memcpy(buf + offset, &ext_backing_fmt, sizeof(ext_backing_fmt));
829 offset += sizeof(ext_backing_fmt);
830
831 memcpy(buf + offset, backing_fmt, strlen(backing_fmt));
832 offset += strlen(backing_fmt);
833
834 memset(buf + offset, 0, padding);
835 offset += padding;
836 }
837
838 memcpy(buf + offset, backing_file, backing_file_len);
839 backing_file_offset = sizeof(QCowHeader) + offset;
840 }
841
Kevin Wolf8b3b7202010-06-16 17:44:35 +0200842 ret = bdrv_pwrite_sync(bs->file, sizeof(QCowHeader), buf, ext_size);
Kevin Wolf756e6732010-01-12 12:55:17 +0100843 if (ret < 0) {
844 goto fail;
845 }
846
847 /* Update header fields */
848 uint64_t be_backing_file_offset = cpu_to_be64(backing_file_offset);
849 uint32_t be_backing_file_size = cpu_to_be32(backing_file_len);
850
Kevin Wolf8b3b7202010-06-16 17:44:35 +0200851 ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, backing_file_offset),
Kevin Wolf756e6732010-01-12 12:55:17 +0100852 &be_backing_file_offset, sizeof(uint64_t));
853 if (ret < 0) {
854 goto fail;
855 }
856
Kevin Wolf8b3b7202010-06-16 17:44:35 +0200857 ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, backing_file_size),
Kevin Wolf756e6732010-01-12 12:55:17 +0100858 &be_backing_file_size, sizeof(uint32_t));
859 if (ret < 0) {
860 goto fail;
861 }
862
863 ret = 0;
864fail:
865 return ret;
866}
867
868static int qcow2_change_backing_file(BlockDriverState *bs,
869 const char *backing_file, const char *backing_fmt)
870{
871 return qcow2_update_ext_header(bs, backing_file, backing_fmt);
872}
873
Kevin Wolfa35e1c12009-08-17 15:50:10 +0200874static int preallocate(BlockDriverState *bs)
875{
Kevin Wolfa35e1c12009-08-17 15:50:10 +0200876 uint64_t nb_sectors;
877 uint64_t offset;
878 int num;
Kevin Wolf148da7e2010-01-20 15:03:01 +0100879 int ret;
Kevin Wolfa35e1c12009-08-17 15:50:10 +0200880 QCowL2Meta meta;
881
882 nb_sectors = bdrv_getlength(bs) >> 9;
883 offset = 0;
Blue Swirl72cf2d42009-09-12 07:36:22 +0000884 QLIST_INIT(&meta.dependent_requests);
Kevin Wolf148da7e2010-01-20 15:03:01 +0100885 meta.cluster_offset = 0;
Kevin Wolfa35e1c12009-08-17 15:50:10 +0200886
887 while (nb_sectors) {
888 num = MIN(nb_sectors, INT_MAX >> 9);
Kevin Wolf148da7e2010-01-20 15:03:01 +0100889 ret = qcow2_alloc_cluster_offset(bs, offset, 0, num, &num, &meta);
Kevin Wolf148da7e2010-01-20 15:03:01 +0100890 if (ret < 0) {
Kevin Wolf19dbcbf2010-06-22 16:59:46 +0200891 return ret;
Kevin Wolfa35e1c12009-08-17 15:50:10 +0200892 }
893
Kevin Wolf19dbcbf2010-06-22 16:59:46 +0200894 ret = qcow2_alloc_cluster_link_l2(bs, &meta);
895 if (ret < 0) {
Kevin Wolf148da7e2010-01-20 15:03:01 +0100896 qcow2_free_any_clusters(bs, meta.cluster_offset, meta.nb_clusters);
Kevin Wolf19dbcbf2010-06-22 16:59:46 +0200897 return ret;
Kevin Wolfa35e1c12009-08-17 15:50:10 +0200898 }
899
Kevin Wolff2149782009-08-31 16:48:49 +0200900 /* There are no dependent requests, but we need to remove our request
901 * from the list of in-flight requests */
902 run_dependent_requests(&meta);
903
Kevin Wolfa35e1c12009-08-17 15:50:10 +0200904 /* TODO Preallocate data if requested */
905
906 nb_sectors -= num;
907 offset += num << 9;
908 }
909
910 /*
911 * It is expected that the image file is large enough to actually contain
912 * all of the allocated clusters (otherwise we get failing reads after
913 * EOF). Extend the image to the last allocated sector.
914 */
Kevin Wolf148da7e2010-01-20 15:03:01 +0100915 if (meta.cluster_offset != 0) {
Kevin Wolfea80b902009-08-31 12:26:57 +0200916 uint8_t buf[512];
917 memset(buf, 0, 512);
Kevin Wolf19dbcbf2010-06-22 16:59:46 +0200918 ret = bdrv_write(bs->file, (meta.cluster_offset >> 9) + num - 1, buf, 1);
919 if (ret < 0) {
920 return ret;
921 }
Kevin Wolfa35e1c12009-08-17 15:50:10 +0200922 }
923
924 return 0;
925}
926
Jes Sorensen7c80ab32010-12-17 16:02:39 +0100927static int qcow2_create2(const char *filename, int64_t total_size,
928 const char *backing_file, const char *backing_format,
929 int flags, size_t cluster_size, int prealloc,
930 QEMUOptionParameter *options)
Kevin Wolfa9420732010-06-11 21:37:37 +0200931{
932 /* Calulate cluster_bits */
933 int cluster_bits;
934 cluster_bits = ffs(cluster_size) - 1;
935 if (cluster_bits < MIN_CLUSTER_BITS || cluster_bits > MAX_CLUSTER_BITS ||
936 (1 << cluster_bits) != cluster_size)
937 {
938 error_report(
Markus Armbruster6daf1942011-06-22 14:03:54 +0200939 "Cluster size must be a power of two between %d and %dk",
Kevin Wolfa9420732010-06-11 21:37:37 +0200940 1 << MIN_CLUSTER_BITS, 1 << (MAX_CLUSTER_BITS - 10));
941 return -EINVAL;
942 }
943
944 /*
945 * Open the image file and write a minimal qcow2 header.
946 *
947 * We keep things simple and start with a zero-sized image. We also
948 * do without refcount blocks or a L1 table for now. We'll fix the
949 * inconsistency later.
950 *
951 * We do need a refcount table because growing the refcount table means
952 * allocating two new refcount blocks - the seconds of which would be at
953 * 2 GB for 64k clusters, and we don't want to have a 2 GB initial file
954 * size for any qcow2 image.
955 */
956 BlockDriverState* bs;
957 QCowHeader header;
958 uint8_t* refcount_table;
959 int ret;
960
961 ret = bdrv_create_file(filename, options);
962 if (ret < 0) {
963 return ret;
964 }
965
966 ret = bdrv_file_open(&bs, filename, BDRV_O_RDWR);
967 if (ret < 0) {
968 return ret;
969 }
970
971 /* Write the header */
972 memset(&header, 0, sizeof(header));
973 header.magic = cpu_to_be32(QCOW_MAGIC);
974 header.version = cpu_to_be32(QCOW_VERSION);
975 header.cluster_bits = cpu_to_be32(cluster_bits);
976 header.size = cpu_to_be64(0);
977 header.l1_table_offset = cpu_to_be64(0);
978 header.l1_size = cpu_to_be32(0);
979 header.refcount_table_offset = cpu_to_be64(cluster_size);
980 header.refcount_table_clusters = cpu_to_be32(1);
981
982 if (flags & BLOCK_FLAG_ENCRYPT) {
983 header.crypt_method = cpu_to_be32(QCOW_CRYPT_AES);
984 } else {
985 header.crypt_method = cpu_to_be32(QCOW_CRYPT_NONE);
986 }
987
988 ret = bdrv_pwrite(bs, 0, &header, sizeof(header));
989 if (ret < 0) {
990 goto out;
991 }
992
993 /* Write an empty refcount table */
994 refcount_table = qemu_mallocz(cluster_size);
995 ret = bdrv_pwrite(bs, cluster_size, refcount_table, cluster_size);
996 qemu_free(refcount_table);
997
998 if (ret < 0) {
999 goto out;
1000 }
1001
1002 bdrv_close(bs);
1003
1004 /*
1005 * And now open the image and make it consistent first (i.e. increase the
1006 * refcount of the cluster that is occupied by the header and the refcount
1007 * table)
1008 */
1009 BlockDriver* drv = bdrv_find_format("qcow2");
1010 assert(drv != NULL);
Kevin Wolfe1a71072011-01-27 16:46:01 +01001011 ret = bdrv_open(bs, filename,
1012 BDRV_O_RDWR | BDRV_O_CACHE_WB | BDRV_O_NO_FLUSH, drv);
Kevin Wolfa9420732010-06-11 21:37:37 +02001013 if (ret < 0) {
1014 goto out;
1015 }
1016
1017 ret = qcow2_alloc_clusters(bs, 2 * cluster_size);
1018 if (ret < 0) {
1019 goto out;
1020
1021 } else if (ret != 0) {
1022 error_report("Huh, first cluster in empty image is already in use?");
1023 abort();
1024 }
1025
1026 /* Okay, now that we have a valid image, let's give it the right size */
1027 ret = bdrv_truncate(bs, total_size * BDRV_SECTOR_SIZE);
1028 if (ret < 0) {
1029 goto out;
1030 }
1031
1032 /* Want a backing file? There you go.*/
1033 if (backing_file) {
1034 ret = bdrv_change_backing_file(bs, backing_file, backing_format);
1035 if (ret < 0) {
1036 goto out;
1037 }
1038 }
1039
1040 /* And if we're supposed to preallocate metadata, do that now */
1041 if (prealloc) {
1042 ret = preallocate(bs);
1043 if (ret < 0) {
1044 goto out;
1045 }
1046 }
1047
1048 ret = 0;
1049out:
1050 bdrv_delete(bs);
1051 return ret;
1052}
Kevin Wolfde5f3f42010-05-07 12:43:45 +02001053
Jes Sorensen7c80ab32010-12-17 16:02:39 +01001054static int qcow2_create(const char *filename, QEMUOptionParameter *options)
Kevin Wolfde5f3f42010-05-07 12:43:45 +02001055{
1056 const char *backing_file = NULL;
1057 const char *backing_fmt = NULL;
1058 uint64_t sectors = 0;
1059 int flags = 0;
Kevin Wolf99cce9f2011-05-31 15:01:46 +02001060 size_t cluster_size = DEFAULT_CLUSTER_SIZE;
Kevin Wolfde5f3f42010-05-07 12:43:45 +02001061 int prealloc = 0;
1062
1063 /* Read out options */
1064 while (options && options->name) {
1065 if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
1066 sectors = options->value.n / 512;
1067 } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FILE)) {
1068 backing_file = options->value.s;
1069 } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FMT)) {
1070 backing_fmt = options->value.s;
1071 } else if (!strcmp(options->name, BLOCK_OPT_ENCRYPT)) {
1072 flags |= options->value.n ? BLOCK_FLAG_ENCRYPT : 0;
1073 } else if (!strcmp(options->name, BLOCK_OPT_CLUSTER_SIZE)) {
1074 if (options->value.n) {
1075 cluster_size = options->value.n;
1076 }
1077 } else if (!strcmp(options->name, BLOCK_OPT_PREALLOC)) {
1078 if (!options->value.s || !strcmp(options->value.s, "off")) {
1079 prealloc = 0;
1080 } else if (!strcmp(options->value.s, "metadata")) {
1081 prealloc = 1;
1082 } else {
1083 fprintf(stderr, "Invalid preallocation mode: '%s'\n",
1084 options->value.s);
1085 return -EINVAL;
1086 }
1087 }
1088 options++;
1089 }
1090
1091 if (backing_file && prealloc) {
1092 fprintf(stderr, "Backing file and preallocation cannot be used at "
1093 "the same time\n");
1094 return -EINVAL;
1095 }
1096
Jes Sorensen7c80ab32010-12-17 16:02:39 +01001097 return qcow2_create2(filename, sectors, backing_file, backing_fmt, flags,
1098 cluster_size, prealloc, options);
Kevin Wolfde5f3f42010-05-07 12:43:45 +02001099}
1100
Jes Sorensen7c80ab32010-12-17 16:02:39 +01001101static int qcow2_make_empty(BlockDriverState *bs)
Blue Swirl20d97352010-04-23 20:19:47 +00001102{
1103#if 0
1104 /* XXX: not correct */
1105 BDRVQcowState *s = bs->opaque;
1106 uint32_t l1_length = s->l1_size * sizeof(uint64_t);
1107 int ret;
1108
1109 memset(s->l1_table, 0, l1_length);
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001110 if (bdrv_pwrite(bs->file, s->l1_table_offset, s->l1_table, l1_length) < 0)
Blue Swirl20d97352010-04-23 20:19:47 +00001111 return -1;
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001112 ret = bdrv_truncate(bs->file, s->l1_table_offset + l1_length);
Blue Swirl20d97352010-04-23 20:19:47 +00001113 if (ret < 0)
1114 return ret;
1115
1116 l2_cache_reset(bs);
1117#endif
1118 return 0;
1119}
1120
Kevin Wolf5ea929e2011-01-26 16:56:48 +01001121static int qcow2_discard(BlockDriverState *bs, int64_t sector_num,
1122 int nb_sectors)
1123{
1124 return qcow2_discard_clusters(bs, sector_num << BDRV_SECTOR_BITS,
1125 nb_sectors);
1126}
1127
Stefan Hajnoczi419b19d2010-04-28 11:36:11 +01001128static int qcow2_truncate(BlockDriverState *bs, int64_t offset)
1129{
1130 BDRVQcowState *s = bs->opaque;
1131 int ret, new_l1_size;
1132
1133 if (offset & 511) {
1134 return -EINVAL;
1135 }
1136
1137 /* cannot proceed if image has snapshots */
1138 if (s->nb_snapshots) {
1139 return -ENOTSUP;
1140 }
1141
1142 /* shrinking is currently not supported */
1143 if (offset < bs->total_sectors * 512) {
1144 return -ENOTSUP;
1145 }
1146
1147 new_l1_size = size_to_l1(s, offset);
Stefan Hajnoczi72893752010-10-18 16:53:53 +01001148 ret = qcow2_grow_l1_table(bs, new_l1_size, true);
Stefan Hajnoczi419b19d2010-04-28 11:36:11 +01001149 if (ret < 0) {
1150 return ret;
1151 }
1152
1153 /* write updated header.size */
1154 offset = cpu_to_be64(offset);
Kevin Wolf8b3b7202010-06-16 17:44:35 +02001155 ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, size),
1156 &offset, sizeof(uint64_t));
Stefan Hajnoczi419b19d2010-04-28 11:36:11 +01001157 if (ret < 0) {
1158 return ret;
1159 }
1160
1161 s->l1_vm_state_index = new_l1_size;
1162 return 0;
1163}
1164
Blue Swirl20d97352010-04-23 20:19:47 +00001165/* XXX: put compressed sectors first, then all the cluster aligned
1166 tables to avoid losing bytes in alignment */
Jes Sorensen7c80ab32010-12-17 16:02:39 +01001167static int qcow2_write_compressed(BlockDriverState *bs, int64_t sector_num,
1168 const uint8_t *buf, int nb_sectors)
Blue Swirl20d97352010-04-23 20:19:47 +00001169{
1170 BDRVQcowState *s = bs->opaque;
1171 z_stream strm;
1172 int ret, out_len;
1173 uint8_t *out_buf;
1174 uint64_t cluster_offset;
1175
1176 if (nb_sectors == 0) {
1177 /* align end of file to a sector boundary to ease reading with
1178 sector based I/Os */
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001179 cluster_offset = bdrv_getlength(bs->file);
Blue Swirl20d97352010-04-23 20:19:47 +00001180 cluster_offset = (cluster_offset + 511) & ~511;
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001181 bdrv_truncate(bs->file, cluster_offset);
Blue Swirl20d97352010-04-23 20:19:47 +00001182 return 0;
1183 }
1184
1185 if (nb_sectors != s->cluster_sectors)
1186 return -EINVAL;
1187
1188 out_buf = qemu_malloc(s->cluster_size + (s->cluster_size / 1000) + 128);
1189
1190 /* best compression, small window, no zlib header */
1191 memset(&strm, 0, sizeof(strm));
1192 ret = deflateInit2(&strm, Z_DEFAULT_COMPRESSION,
1193 Z_DEFLATED, -12,
1194 9, Z_DEFAULT_STRATEGY);
1195 if (ret != 0) {
1196 qemu_free(out_buf);
1197 return -1;
1198 }
1199
1200 strm.avail_in = s->cluster_size;
1201 strm.next_in = (uint8_t *)buf;
1202 strm.avail_out = s->cluster_size;
1203 strm.next_out = out_buf;
1204
1205 ret = deflate(&strm, Z_FINISH);
1206 if (ret != Z_STREAM_END && ret != Z_OK) {
1207 qemu_free(out_buf);
1208 deflateEnd(&strm);
1209 return -1;
1210 }
1211 out_len = strm.next_out - out_buf;
1212
1213 deflateEnd(&strm);
1214
1215 if (ret != Z_STREAM_END || out_len >= s->cluster_size) {
1216 /* could not compress: write normal cluster */
1217 bdrv_write(bs, sector_num, buf, s->cluster_sectors);
1218 } else {
1219 cluster_offset = qcow2_alloc_compressed_cluster_offset(bs,
1220 sector_num << 9, out_len);
1221 if (!cluster_offset)
1222 return -1;
1223 cluster_offset &= s->cluster_offset_mask;
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001224 BLKDBG_EVENT(bs->file, BLKDBG_WRITE_COMPRESSED);
1225 if (bdrv_pwrite(bs->file, cluster_offset, out_buf, out_len) != out_len) {
Blue Swirl20d97352010-04-23 20:19:47 +00001226 qemu_free(out_buf);
1227 return -1;
1228 }
1229 }
1230
1231 qemu_free(out_buf);
1232 return 0;
1233}
1234
Jes Sorensen7c80ab32010-12-17 16:02:39 +01001235static int qcow2_flush(BlockDriverState *bs)
Blue Swirl20d97352010-04-23 20:19:47 +00001236{
Kevin Wolf29c1a732011-01-10 17:17:28 +01001237 BDRVQcowState *s = bs->opaque;
1238 int ret;
1239
1240 ret = qcow2_cache_flush(bs, s->l2_table_cache);
1241 if (ret < 0) {
1242 return ret;
1243 }
1244
1245 ret = qcow2_cache_flush(bs, s->refcount_block_cache);
1246 if (ret < 0) {
1247 return ret;
1248 }
1249
Kevin Wolf205ef792010-10-21 16:43:43 +02001250 return bdrv_flush(bs->file);
Blue Swirl20d97352010-04-23 20:19:47 +00001251}
1252
Jes Sorensen7c80ab32010-12-17 16:02:39 +01001253static BlockDriverAIOCB *qcow2_aio_flush(BlockDriverState *bs,
1254 BlockDriverCompletionFunc *cb,
1255 void *opaque)
Blue Swirl20d97352010-04-23 20:19:47 +00001256{
Kevin Wolf29c1a732011-01-10 17:17:28 +01001257 BDRVQcowState *s = bs->opaque;
1258 int ret;
1259
1260 ret = qcow2_cache_flush(bs, s->l2_table_cache);
1261 if (ret < 0) {
1262 return NULL;
1263 }
1264
1265 ret = qcow2_cache_flush(bs, s->refcount_block_cache);
1266 if (ret < 0) {
1267 return NULL;
1268 }
1269
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001270 return bdrv_aio_flush(bs->file, cb, opaque);
Blue Swirl20d97352010-04-23 20:19:47 +00001271}
1272
Jes Sorensen7c80ab32010-12-17 16:02:39 +01001273static int64_t qcow2_vm_state_offset(BDRVQcowState *s)
Blue Swirl20d97352010-04-23 20:19:47 +00001274{
1275 return (int64_t)s->l1_vm_state_index << (s->cluster_bits + s->l2_bits);
1276}
1277
Jes Sorensen7c80ab32010-12-17 16:02:39 +01001278static int qcow2_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
Blue Swirl20d97352010-04-23 20:19:47 +00001279{
1280 BDRVQcowState *s = bs->opaque;
1281 bdi->cluster_size = s->cluster_size;
Jes Sorensen7c80ab32010-12-17 16:02:39 +01001282 bdi->vm_state_offset = qcow2_vm_state_offset(s);
Blue Swirl20d97352010-04-23 20:19:47 +00001283 return 0;
1284}
1285
1286
Jes Sorensen7c80ab32010-12-17 16:02:39 +01001287static int qcow2_check(BlockDriverState *bs, BdrvCheckResult *result)
Blue Swirl20d97352010-04-23 20:19:47 +00001288{
Kevin Wolf9ac228e2010-06-29 12:37:54 +02001289 return qcow2_check_refcounts(bs, result);
Blue Swirl20d97352010-04-23 20:19:47 +00001290}
1291
1292#if 0
1293static void dump_refcounts(BlockDriverState *bs)
1294{
1295 BDRVQcowState *s = bs->opaque;
1296 int64_t nb_clusters, k, k1, size;
1297 int refcount;
1298
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001299 size = bdrv_getlength(bs->file);
Blue Swirl20d97352010-04-23 20:19:47 +00001300 nb_clusters = size_to_clusters(s, size);
1301 for(k = 0; k < nb_clusters;) {
1302 k1 = k;
1303 refcount = get_refcount(bs, k);
1304 k++;
1305 while (k < nb_clusters && get_refcount(bs, k) == refcount)
1306 k++;
Blue Swirl0bfcd592010-05-22 08:02:12 +00001307 printf("%" PRId64 ": refcount=%d nb=%" PRId64 "\n", k, refcount,
1308 k - k1);
Blue Swirl20d97352010-04-23 20:19:47 +00001309 }
1310}
1311#endif
1312
Jes Sorensen7c80ab32010-12-17 16:02:39 +01001313static int qcow2_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
1314 int64_t pos, int size)
Blue Swirl20d97352010-04-23 20:19:47 +00001315{
1316 BDRVQcowState *s = bs->opaque;
1317 int growable = bs->growable;
1318 int ret;
1319
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001320 BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_SAVE);
Blue Swirl20d97352010-04-23 20:19:47 +00001321 bs->growable = 1;
Jes Sorensen7c80ab32010-12-17 16:02:39 +01001322 ret = bdrv_pwrite(bs, qcow2_vm_state_offset(s) + pos, buf, size);
Blue Swirl20d97352010-04-23 20:19:47 +00001323 bs->growable = growable;
1324
1325 return ret;
1326}
1327
Jes Sorensen7c80ab32010-12-17 16:02:39 +01001328static int qcow2_load_vmstate(BlockDriverState *bs, uint8_t *buf,
1329 int64_t pos, int size)
Blue Swirl20d97352010-04-23 20:19:47 +00001330{
1331 BDRVQcowState *s = bs->opaque;
1332 int growable = bs->growable;
1333 int ret;
1334
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001335 BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_LOAD);
Blue Swirl20d97352010-04-23 20:19:47 +00001336 bs->growable = 1;
Jes Sorensen7c80ab32010-12-17 16:02:39 +01001337 ret = bdrv_pread(bs, qcow2_vm_state_offset(s) + pos, buf, size);
Blue Swirl20d97352010-04-23 20:19:47 +00001338 bs->growable = growable;
1339
1340 return ret;
1341}
1342
Jes Sorensen7c80ab32010-12-17 16:02:39 +01001343static QEMUOptionParameter qcow2_create_options[] = {
Blue Swirl20d97352010-04-23 20:19:47 +00001344 {
1345 .name = BLOCK_OPT_SIZE,
1346 .type = OPT_SIZE,
1347 .help = "Virtual disk size"
1348 },
1349 {
1350 .name = BLOCK_OPT_BACKING_FILE,
1351 .type = OPT_STRING,
1352 .help = "File name of a base image"
1353 },
1354 {
1355 .name = BLOCK_OPT_BACKING_FMT,
1356 .type = OPT_STRING,
1357 .help = "Image format of the base image"
1358 },
1359 {
1360 .name = BLOCK_OPT_ENCRYPT,
1361 .type = OPT_FLAG,
1362 .help = "Encrypt the image"
1363 },
1364 {
1365 .name = BLOCK_OPT_CLUSTER_SIZE,
1366 .type = OPT_SIZE,
Kevin Wolf99cce9f2011-05-31 15:01:46 +02001367 .help = "qcow2 cluster size",
1368 .value = { .n = DEFAULT_CLUSTER_SIZE },
Blue Swirl20d97352010-04-23 20:19:47 +00001369 },
1370 {
1371 .name = BLOCK_OPT_PREALLOC,
1372 .type = OPT_STRING,
1373 .help = "Preallocation mode (allowed values: off, metadata)"
1374 },
1375 { NULL }
1376};
1377
1378static BlockDriver bdrv_qcow2 = {
Jes Sorensen7c80ab32010-12-17 16:02:39 +01001379 .format_name = "qcow2",
1380 .instance_size = sizeof(BDRVQcowState),
1381 .bdrv_probe = qcow2_probe,
1382 .bdrv_open = qcow2_open,
1383 .bdrv_close = qcow2_close,
1384 .bdrv_create = qcow2_create,
1385 .bdrv_flush = qcow2_flush,
1386 .bdrv_is_allocated = qcow2_is_allocated,
1387 .bdrv_set_key = qcow2_set_key,
1388 .bdrv_make_empty = qcow2_make_empty,
Blue Swirl20d97352010-04-23 20:19:47 +00001389
Jes Sorensen7c80ab32010-12-17 16:02:39 +01001390 .bdrv_aio_readv = qcow2_aio_readv,
1391 .bdrv_aio_writev = qcow2_aio_writev,
1392 .bdrv_aio_flush = qcow2_aio_flush,
Stefan Hajnoczi419b19d2010-04-28 11:36:11 +01001393
Kevin Wolf5ea929e2011-01-26 16:56:48 +01001394 .bdrv_discard = qcow2_discard,
Stefan Hajnoczi419b19d2010-04-28 11:36:11 +01001395 .bdrv_truncate = qcow2_truncate,
Jes Sorensen7c80ab32010-12-17 16:02:39 +01001396 .bdrv_write_compressed = qcow2_write_compressed,
Blue Swirl20d97352010-04-23 20:19:47 +00001397
1398 .bdrv_snapshot_create = qcow2_snapshot_create,
1399 .bdrv_snapshot_goto = qcow2_snapshot_goto,
1400 .bdrv_snapshot_delete = qcow2_snapshot_delete,
1401 .bdrv_snapshot_list = qcow2_snapshot_list,
edison51ef6722010-09-21 19:58:41 -07001402 .bdrv_snapshot_load_tmp = qcow2_snapshot_load_tmp,
Jes Sorensen7c80ab32010-12-17 16:02:39 +01001403 .bdrv_get_info = qcow2_get_info,
Blue Swirl20d97352010-04-23 20:19:47 +00001404
Jes Sorensen7c80ab32010-12-17 16:02:39 +01001405 .bdrv_save_vmstate = qcow2_save_vmstate,
1406 .bdrv_load_vmstate = qcow2_load_vmstate,
Blue Swirl20d97352010-04-23 20:19:47 +00001407
1408 .bdrv_change_backing_file = qcow2_change_backing_file,
1409
Jes Sorensen7c80ab32010-12-17 16:02:39 +01001410 .create_options = qcow2_create_options,
1411 .bdrv_check = qcow2_check,
Blue Swirl20d97352010-04-23 20:19:47 +00001412};
1413
Anthony Liguori5efa9d52009-05-09 17:03:42 -05001414static void bdrv_qcow2_init(void)
1415{
1416 bdrv_register(&bdrv_qcow2);
1417}
1418
1419block_init(bdrv_qcow2_init);