block: Catch backing files assigned to non-COW drivers
[qemu.git] / block / qcow.c
1 /*
2 * Block driver for the QCOW format
3 *
4 * Copyright (c) 2004-2006 Fabrice Bellard
5 *
6 * 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 */
24 #include "qemu-common.h"
25 #include "block/block_int.h"
26 #include "qemu/module.h"
27 #include <zlib.h>
28 #include "qemu/aes.h"
29 #include "migration/migration.h"
30
31 /**************************************************************/
32 /* QEMU COW block driver with compression and encryption support */
33
34 #define QCOW_MAGIC (('Q' << 24) | ('F' << 16) | ('I' << 8) | 0xfb)
35 #define QCOW_VERSION 1
36
37 #define QCOW_CRYPT_NONE 0
38 #define QCOW_CRYPT_AES 1
39
40 #define QCOW_OFLAG_COMPRESSED (1LL << 63)
41
42 typedef struct QCowHeader {
43 uint32_t magic;
44 uint32_t version;
45 uint64_t backing_file_offset;
46 uint32_t backing_file_size;
47 uint32_t mtime;
48 uint64_t size; /* in bytes */
49 uint8_t cluster_bits;
50 uint8_t l2_bits;
51 uint16_t padding;
52 uint32_t crypt_method;
53 uint64_t l1_table_offset;
54 } QEMU_PACKED QCowHeader;
55
56 #define L2_CACHE_SIZE 16
57
58 typedef struct BDRVQcowState {
59 int cluster_bits;
60 int cluster_size;
61 int cluster_sectors;
62 int l2_bits;
63 int l2_size;
64 unsigned int l1_size;
65 uint64_t cluster_offset_mask;
66 uint64_t l1_table_offset;
67 uint64_t *l1_table;
68 uint64_t *l2_cache;
69 uint64_t l2_cache_offsets[L2_CACHE_SIZE];
70 uint32_t l2_cache_counts[L2_CACHE_SIZE];
71 uint8_t *cluster_cache;
72 uint8_t *cluster_data;
73 uint64_t cluster_cache_offset;
74 uint32_t crypt_method; /* current crypt method, 0 if no key yet */
75 uint32_t crypt_method_header;
76 AES_KEY aes_encrypt_key;
77 AES_KEY aes_decrypt_key;
78 CoMutex lock;
79 Error *migration_blocker;
80 } BDRVQcowState;
81
82 static int decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset);
83
84 static int qcow_probe(const uint8_t *buf, int buf_size, const char *filename)
85 {
86 const QCowHeader *cow_header = (const void *)buf;
87
88 if (buf_size >= sizeof(QCowHeader) &&
89 be32_to_cpu(cow_header->magic) == QCOW_MAGIC &&
90 be32_to_cpu(cow_header->version) == QCOW_VERSION)
91 return 100;
92 else
93 return 0;
94 }
95
96 static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
97 Error **errp)
98 {
99 BDRVQcowState *s = bs->opaque;
100 unsigned int len, i, shift;
101 int ret;
102 QCowHeader header;
103
104 ret = bdrv_pread(bs->file, 0, &header, sizeof(header));
105 if (ret < 0) {
106 goto fail;
107 }
108 be32_to_cpus(&header.magic);
109 be32_to_cpus(&header.version);
110 be64_to_cpus(&header.backing_file_offset);
111 be32_to_cpus(&header.backing_file_size);
112 be32_to_cpus(&header.mtime);
113 be64_to_cpus(&header.size);
114 be32_to_cpus(&header.crypt_method);
115 be64_to_cpus(&header.l1_table_offset);
116
117 if (header.magic != QCOW_MAGIC) {
118 error_setg(errp, "Image not in qcow format");
119 ret = -EINVAL;
120 goto fail;
121 }
122 if (header.version != QCOW_VERSION) {
123 char version[64];
124 snprintf(version, sizeof(version), "QCOW version %" PRIu32,
125 header.version);
126 error_set(errp, QERR_UNKNOWN_BLOCK_FORMAT_FEATURE,
127 bs->device_name, "qcow", version);
128 ret = -ENOTSUP;
129 goto fail;
130 }
131
132 if (header.size <= 1) {
133 error_setg(errp, "Image size is too small (must be at least 2 bytes)");
134 ret = -EINVAL;
135 goto fail;
136 }
137 if (header.cluster_bits < 9 || header.cluster_bits > 16) {
138 error_setg(errp, "Cluster size must be between 512 and 64k");
139 ret = -EINVAL;
140 goto fail;
141 }
142
143 /* l2_bits specifies number of entries; storing a uint64_t in each entry,
144 * so bytes = num_entries << 3. */
145 if (header.l2_bits < 9 - 3 || header.l2_bits > 16 - 3) {
146 error_setg(errp, "L2 table size must be between 512 and 64k");
147 ret = -EINVAL;
148 goto fail;
149 }
150
151 if (header.crypt_method > QCOW_CRYPT_AES) {
152 error_setg(errp, "invalid encryption method in qcow header");
153 ret = -EINVAL;
154 goto fail;
155 }
156 s->crypt_method_header = header.crypt_method;
157 if (s->crypt_method_header) {
158 bs->encrypted = 1;
159 }
160 s->cluster_bits = header.cluster_bits;
161 s->cluster_size = 1 << s->cluster_bits;
162 s->cluster_sectors = 1 << (s->cluster_bits - 9);
163 s->l2_bits = header.l2_bits;
164 s->l2_size = 1 << s->l2_bits;
165 bs->total_sectors = header.size / 512;
166 s->cluster_offset_mask = (1LL << (63 - s->cluster_bits)) - 1;
167
168 /* read the level 1 table */
169 shift = s->cluster_bits + s->l2_bits;
170 if (header.size > UINT64_MAX - (1LL << shift)) {
171 error_setg(errp, "Image too large");
172 ret = -EINVAL;
173 goto fail;
174 } else {
175 uint64_t l1_size = (header.size + (1LL << shift) - 1) >> shift;
176 if (l1_size > INT_MAX / sizeof(uint64_t)) {
177 error_setg(errp, "Image too large");
178 ret = -EINVAL;
179 goto fail;
180 }
181 s->l1_size = l1_size;
182 }
183
184 s->l1_table_offset = header.l1_table_offset;
185 s->l1_table = g_malloc(s->l1_size * sizeof(uint64_t));
186
187 ret = bdrv_pread(bs->file, s->l1_table_offset, s->l1_table,
188 s->l1_size * sizeof(uint64_t));
189 if (ret < 0) {
190 goto fail;
191 }
192
193 for(i = 0;i < s->l1_size; i++) {
194 be64_to_cpus(&s->l1_table[i]);
195 }
196 /* alloc L2 cache */
197 s->l2_cache = g_malloc(s->l2_size * L2_CACHE_SIZE * sizeof(uint64_t));
198 s->cluster_cache = g_malloc(s->cluster_size);
199 s->cluster_data = g_malloc(s->cluster_size);
200 s->cluster_cache_offset = -1;
201
202 /* read the backing file name */
203 if (header.backing_file_offset != 0) {
204 len = header.backing_file_size;
205 if (len > 1023) {
206 error_setg(errp, "Backing file name too long");
207 ret = -EINVAL;
208 goto fail;
209 }
210 ret = bdrv_pread(bs->file, header.backing_file_offset,
211 bs->backing_file, len);
212 if (ret < 0) {
213 goto fail;
214 }
215 bs->backing_file[len] = '\0';
216 }
217
218 /* Disable migration when qcow images are used */
219 error_set(&s->migration_blocker,
220 QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,
221 "qcow", bs->device_name, "live migration");
222 migrate_add_blocker(s->migration_blocker);
223
224 qemu_co_mutex_init(&s->lock);
225 return 0;
226
227 fail:
228 g_free(s->l1_table);
229 g_free(s->l2_cache);
230 g_free(s->cluster_cache);
231 g_free(s->cluster_data);
232 return ret;
233 }
234
235
236 /* We have nothing to do for QCOW reopen, stubs just return
237 * success */
238 static int qcow_reopen_prepare(BDRVReopenState *state,
239 BlockReopenQueue *queue, Error **errp)
240 {
241 return 0;
242 }
243
244 static int qcow_set_key(BlockDriverState *bs, const char *key)
245 {
246 BDRVQcowState *s = bs->opaque;
247 uint8_t keybuf[16];
248 int len, i;
249
250 memset(keybuf, 0, 16);
251 len = strlen(key);
252 if (len > 16)
253 len = 16;
254 /* XXX: we could compress the chars to 7 bits to increase
255 entropy */
256 for(i = 0;i < len;i++) {
257 keybuf[i] = key[i];
258 }
259 s->crypt_method = s->crypt_method_header;
260
261 if (AES_set_encrypt_key(keybuf, 128, &s->aes_encrypt_key) != 0)
262 return -1;
263 if (AES_set_decrypt_key(keybuf, 128, &s->aes_decrypt_key) != 0)
264 return -1;
265 return 0;
266 }
267
268 /* The crypt function is compatible with the linux cryptoloop
269 algorithm for < 4 GB images. NOTE: out_buf == in_buf is
270 supported */
271 static void encrypt_sectors(BDRVQcowState *s, int64_t sector_num,
272 uint8_t *out_buf, const uint8_t *in_buf,
273 int nb_sectors, int enc,
274 const AES_KEY *key)
275 {
276 union {
277 uint64_t ll[2];
278 uint8_t b[16];
279 } ivec;
280 int i;
281
282 for(i = 0; i < nb_sectors; i++) {
283 ivec.ll[0] = cpu_to_le64(sector_num);
284 ivec.ll[1] = 0;
285 AES_cbc_encrypt(in_buf, out_buf, 512, key,
286 ivec.b, enc);
287 sector_num++;
288 in_buf += 512;
289 out_buf += 512;
290 }
291 }
292
293 /* 'allocate' is:
294 *
295 * 0 to not allocate.
296 *
297 * 1 to allocate a normal cluster (for sector indexes 'n_start' to
298 * 'n_end')
299 *
300 * 2 to allocate a compressed cluster of size
301 * 'compressed_size'. 'compressed_size' must be > 0 and <
302 * cluster_size
303 *
304 * return 0 if not allocated.
305 */
306 static uint64_t get_cluster_offset(BlockDriverState *bs,
307 uint64_t offset, int allocate,
308 int compressed_size,
309 int n_start, int n_end)
310 {
311 BDRVQcowState *s = bs->opaque;
312 int min_index, i, j, l1_index, l2_index;
313 uint64_t l2_offset, *l2_table, cluster_offset, tmp;
314 uint32_t min_count;
315 int new_l2_table;
316
317 l1_index = offset >> (s->l2_bits + s->cluster_bits);
318 l2_offset = s->l1_table[l1_index];
319 new_l2_table = 0;
320 if (!l2_offset) {
321 if (!allocate)
322 return 0;
323 /* allocate a new l2 entry */
324 l2_offset = bdrv_getlength(bs->file);
325 /* round to cluster size */
326 l2_offset = (l2_offset + s->cluster_size - 1) & ~(s->cluster_size - 1);
327 /* update the L1 entry */
328 s->l1_table[l1_index] = l2_offset;
329 tmp = cpu_to_be64(l2_offset);
330 if (bdrv_pwrite_sync(bs->file,
331 s->l1_table_offset + l1_index * sizeof(tmp),
332 &tmp, sizeof(tmp)) < 0)
333 return 0;
334 new_l2_table = 1;
335 }
336 for(i = 0; i < L2_CACHE_SIZE; i++) {
337 if (l2_offset == s->l2_cache_offsets[i]) {
338 /* increment the hit count */
339 if (++s->l2_cache_counts[i] == 0xffffffff) {
340 for(j = 0; j < L2_CACHE_SIZE; j++) {
341 s->l2_cache_counts[j] >>= 1;
342 }
343 }
344 l2_table = s->l2_cache + (i << s->l2_bits);
345 goto found;
346 }
347 }
348 /* not found: load a new entry in the least used one */
349 min_index = 0;
350 min_count = 0xffffffff;
351 for(i = 0; i < L2_CACHE_SIZE; i++) {
352 if (s->l2_cache_counts[i] < min_count) {
353 min_count = s->l2_cache_counts[i];
354 min_index = i;
355 }
356 }
357 l2_table = s->l2_cache + (min_index << s->l2_bits);
358 if (new_l2_table) {
359 memset(l2_table, 0, s->l2_size * sizeof(uint64_t));
360 if (bdrv_pwrite_sync(bs->file, l2_offset, l2_table,
361 s->l2_size * sizeof(uint64_t)) < 0)
362 return 0;
363 } else {
364 if (bdrv_pread(bs->file, l2_offset, l2_table, s->l2_size * sizeof(uint64_t)) !=
365 s->l2_size * sizeof(uint64_t))
366 return 0;
367 }
368 s->l2_cache_offsets[min_index] = l2_offset;
369 s->l2_cache_counts[min_index] = 1;
370 found:
371 l2_index = (offset >> s->cluster_bits) & (s->l2_size - 1);
372 cluster_offset = be64_to_cpu(l2_table[l2_index]);
373 if (!cluster_offset ||
374 ((cluster_offset & QCOW_OFLAG_COMPRESSED) && allocate == 1)) {
375 if (!allocate)
376 return 0;
377 /* allocate a new cluster */
378 if ((cluster_offset & QCOW_OFLAG_COMPRESSED) &&
379 (n_end - n_start) < s->cluster_sectors) {
380 /* if the cluster is already compressed, we must
381 decompress it in the case it is not completely
382 overwritten */
383 if (decompress_cluster(bs, cluster_offset) < 0)
384 return 0;
385 cluster_offset = bdrv_getlength(bs->file);
386 cluster_offset = (cluster_offset + s->cluster_size - 1) &
387 ~(s->cluster_size - 1);
388 /* write the cluster content */
389 if (bdrv_pwrite(bs->file, cluster_offset, s->cluster_cache, s->cluster_size) !=
390 s->cluster_size)
391 return -1;
392 } else {
393 cluster_offset = bdrv_getlength(bs->file);
394 if (allocate == 1) {
395 /* round to cluster size */
396 cluster_offset = (cluster_offset + s->cluster_size - 1) &
397 ~(s->cluster_size - 1);
398 bdrv_truncate(bs->file, cluster_offset + s->cluster_size);
399 /* if encrypted, we must initialize the cluster
400 content which won't be written */
401 if (s->crypt_method &&
402 (n_end - n_start) < s->cluster_sectors) {
403 uint64_t start_sect;
404 start_sect = (offset & ~(s->cluster_size - 1)) >> 9;
405 memset(s->cluster_data + 512, 0x00, 512);
406 for(i = 0; i < s->cluster_sectors; i++) {
407 if (i < n_start || i >= n_end) {
408 encrypt_sectors(s, start_sect + i,
409 s->cluster_data,
410 s->cluster_data + 512, 1, 1,
411 &s->aes_encrypt_key);
412 if (bdrv_pwrite(bs->file, cluster_offset + i * 512,
413 s->cluster_data, 512) != 512)
414 return -1;
415 }
416 }
417 }
418 } else if (allocate == 2) {
419 cluster_offset |= QCOW_OFLAG_COMPRESSED |
420 (uint64_t)compressed_size << (63 - s->cluster_bits);
421 }
422 }
423 /* update L2 table */
424 tmp = cpu_to_be64(cluster_offset);
425 l2_table[l2_index] = tmp;
426 if (bdrv_pwrite_sync(bs->file, l2_offset + l2_index * sizeof(tmp),
427 &tmp, sizeof(tmp)) < 0)
428 return 0;
429 }
430 return cluster_offset;
431 }
432
433 static int64_t coroutine_fn qcow_co_get_block_status(BlockDriverState *bs,
434 int64_t sector_num, int nb_sectors, int *pnum)
435 {
436 BDRVQcowState *s = bs->opaque;
437 int index_in_cluster, n;
438 uint64_t cluster_offset;
439
440 qemu_co_mutex_lock(&s->lock);
441 cluster_offset = get_cluster_offset(bs, sector_num << 9, 0, 0, 0, 0);
442 qemu_co_mutex_unlock(&s->lock);
443 index_in_cluster = sector_num & (s->cluster_sectors - 1);
444 n = s->cluster_sectors - index_in_cluster;
445 if (n > nb_sectors)
446 n = nb_sectors;
447 *pnum = n;
448 if (!cluster_offset) {
449 return 0;
450 }
451 if ((cluster_offset & QCOW_OFLAG_COMPRESSED) || s->crypt_method) {
452 return BDRV_BLOCK_DATA;
453 }
454 cluster_offset |= (index_in_cluster << BDRV_SECTOR_BITS);
455 return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID | cluster_offset;
456 }
457
458 static int decompress_buffer(uint8_t *out_buf, int out_buf_size,
459 const uint8_t *buf, int buf_size)
460 {
461 z_stream strm1, *strm = &strm1;
462 int ret, out_len;
463
464 memset(strm, 0, sizeof(*strm));
465
466 strm->next_in = (uint8_t *)buf;
467 strm->avail_in = buf_size;
468 strm->next_out = out_buf;
469 strm->avail_out = out_buf_size;
470
471 ret = inflateInit2(strm, -12);
472 if (ret != Z_OK)
473 return -1;
474 ret = inflate(strm, Z_FINISH);
475 out_len = strm->next_out - out_buf;
476 if ((ret != Z_STREAM_END && ret != Z_BUF_ERROR) ||
477 out_len != out_buf_size) {
478 inflateEnd(strm);
479 return -1;
480 }
481 inflateEnd(strm);
482 return 0;
483 }
484
485 static int decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset)
486 {
487 BDRVQcowState *s = bs->opaque;
488 int ret, csize;
489 uint64_t coffset;
490
491 coffset = cluster_offset & s->cluster_offset_mask;
492 if (s->cluster_cache_offset != coffset) {
493 csize = cluster_offset >> (63 - s->cluster_bits);
494 csize &= (s->cluster_size - 1);
495 ret = bdrv_pread(bs->file, coffset, s->cluster_data, csize);
496 if (ret != csize)
497 return -1;
498 if (decompress_buffer(s->cluster_cache, s->cluster_size,
499 s->cluster_data, csize) < 0) {
500 return -1;
501 }
502 s->cluster_cache_offset = coffset;
503 }
504 return 0;
505 }
506
507 static coroutine_fn int qcow_co_readv(BlockDriverState *bs, int64_t sector_num,
508 int nb_sectors, QEMUIOVector *qiov)
509 {
510 BDRVQcowState *s = bs->opaque;
511 int index_in_cluster;
512 int ret = 0, n;
513 uint64_t cluster_offset;
514 struct iovec hd_iov;
515 QEMUIOVector hd_qiov;
516 uint8_t *buf;
517 void *orig_buf;
518
519 if (qiov->niov > 1) {
520 buf = orig_buf = qemu_blockalign(bs, qiov->size);
521 } else {
522 orig_buf = NULL;
523 buf = (uint8_t *)qiov->iov->iov_base;
524 }
525
526 qemu_co_mutex_lock(&s->lock);
527
528 while (nb_sectors != 0) {
529 /* prepare next request */
530 cluster_offset = get_cluster_offset(bs, sector_num << 9,
531 0, 0, 0, 0);
532 index_in_cluster = sector_num & (s->cluster_sectors - 1);
533 n = s->cluster_sectors - index_in_cluster;
534 if (n > nb_sectors) {
535 n = nb_sectors;
536 }
537
538 if (!cluster_offset) {
539 if (bs->backing_hd) {
540 /* read from the base image */
541 hd_iov.iov_base = (void *)buf;
542 hd_iov.iov_len = n * 512;
543 qemu_iovec_init_external(&hd_qiov, &hd_iov, 1);
544 qemu_co_mutex_unlock(&s->lock);
545 ret = bdrv_co_readv(bs->backing_hd, sector_num,
546 n, &hd_qiov);
547 qemu_co_mutex_lock(&s->lock);
548 if (ret < 0) {
549 goto fail;
550 }
551 } else {
552 /* Note: in this case, no need to wait */
553 memset(buf, 0, 512 * n);
554 }
555 } else if (cluster_offset & QCOW_OFLAG_COMPRESSED) {
556 /* add AIO support for compressed blocks ? */
557 if (decompress_cluster(bs, cluster_offset) < 0) {
558 goto fail;
559 }
560 memcpy(buf,
561 s->cluster_cache + index_in_cluster * 512, 512 * n);
562 } else {
563 if ((cluster_offset & 511) != 0) {
564 goto fail;
565 }
566 hd_iov.iov_base = (void *)buf;
567 hd_iov.iov_len = n * 512;
568 qemu_iovec_init_external(&hd_qiov, &hd_iov, 1);
569 qemu_co_mutex_unlock(&s->lock);
570 ret = bdrv_co_readv(bs->file,
571 (cluster_offset >> 9) + index_in_cluster,
572 n, &hd_qiov);
573 qemu_co_mutex_lock(&s->lock);
574 if (ret < 0) {
575 break;
576 }
577 if (s->crypt_method) {
578 encrypt_sectors(s, sector_num, buf, buf,
579 n, 0,
580 &s->aes_decrypt_key);
581 }
582 }
583 ret = 0;
584
585 nb_sectors -= n;
586 sector_num += n;
587 buf += n * 512;
588 }
589
590 done:
591 qemu_co_mutex_unlock(&s->lock);
592
593 if (qiov->niov > 1) {
594 qemu_iovec_from_buf(qiov, 0, orig_buf, qiov->size);
595 qemu_vfree(orig_buf);
596 }
597
598 return ret;
599
600 fail:
601 ret = -EIO;
602 goto done;
603 }
604
605 static coroutine_fn int qcow_co_writev(BlockDriverState *bs, int64_t sector_num,
606 int nb_sectors, QEMUIOVector *qiov)
607 {
608 BDRVQcowState *s = bs->opaque;
609 int index_in_cluster;
610 uint64_t cluster_offset;
611 const uint8_t *src_buf;
612 int ret = 0, n;
613 uint8_t *cluster_data = NULL;
614 struct iovec hd_iov;
615 QEMUIOVector hd_qiov;
616 uint8_t *buf;
617 void *orig_buf;
618
619 s->cluster_cache_offset = -1; /* disable compressed cache */
620
621 if (qiov->niov > 1) {
622 buf = orig_buf = qemu_blockalign(bs, qiov->size);
623 qemu_iovec_to_buf(qiov, 0, buf, qiov->size);
624 } else {
625 orig_buf = NULL;
626 buf = (uint8_t *)qiov->iov->iov_base;
627 }
628
629 qemu_co_mutex_lock(&s->lock);
630
631 while (nb_sectors != 0) {
632
633 index_in_cluster = sector_num & (s->cluster_sectors - 1);
634 n = s->cluster_sectors - index_in_cluster;
635 if (n > nb_sectors) {
636 n = nb_sectors;
637 }
638 cluster_offset = get_cluster_offset(bs, sector_num << 9, 1, 0,
639 index_in_cluster,
640 index_in_cluster + n);
641 if (!cluster_offset || (cluster_offset & 511) != 0) {
642 ret = -EIO;
643 break;
644 }
645 if (s->crypt_method) {
646 if (!cluster_data) {
647 cluster_data = g_malloc0(s->cluster_size);
648 }
649 encrypt_sectors(s, sector_num, cluster_data, buf,
650 n, 1, &s->aes_encrypt_key);
651 src_buf = cluster_data;
652 } else {
653 src_buf = buf;
654 }
655
656 hd_iov.iov_base = (void *)src_buf;
657 hd_iov.iov_len = n * 512;
658 qemu_iovec_init_external(&hd_qiov, &hd_iov, 1);
659 qemu_co_mutex_unlock(&s->lock);
660 ret = bdrv_co_writev(bs->file,
661 (cluster_offset >> 9) + index_in_cluster,
662 n, &hd_qiov);
663 qemu_co_mutex_lock(&s->lock);
664 if (ret < 0) {
665 break;
666 }
667 ret = 0;
668
669 nb_sectors -= n;
670 sector_num += n;
671 buf += n * 512;
672 }
673 qemu_co_mutex_unlock(&s->lock);
674
675 if (qiov->niov > 1) {
676 qemu_vfree(orig_buf);
677 }
678 g_free(cluster_data);
679
680 return ret;
681 }
682
683 static void qcow_close(BlockDriverState *bs)
684 {
685 BDRVQcowState *s = bs->opaque;
686
687 g_free(s->l1_table);
688 g_free(s->l2_cache);
689 g_free(s->cluster_cache);
690 g_free(s->cluster_data);
691
692 migrate_del_blocker(s->migration_blocker);
693 error_free(s->migration_blocker);
694 }
695
696 static int qcow_create(const char *filename, QemuOpts *opts, Error **errp)
697 {
698 int header_size, backing_filename_len, l1_size, shift, i;
699 QCowHeader header;
700 uint8_t *tmp;
701 int64_t total_size = 0;
702 char *backing_file = NULL;
703 int flags = 0;
704 Error *local_err = NULL;
705 int ret;
706 BlockDriverState *qcow_bs;
707
708 /* Read out options */
709 total_size = qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0) / 512;
710 backing_file = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FILE);
711 if (qemu_opt_get_bool_del(opts, BLOCK_OPT_ENCRYPT, false)) {
712 flags |= BLOCK_FLAG_ENCRYPT;
713 }
714
715 ret = bdrv_create_file(filename, opts, &local_err);
716 if (ret < 0) {
717 error_propagate(errp, local_err);
718 goto cleanup;
719 }
720
721 qcow_bs = NULL;
722 ret = bdrv_open(&qcow_bs, filename, NULL, NULL,
723 BDRV_O_RDWR | BDRV_O_PROTOCOL, NULL, &local_err);
724 if (ret < 0) {
725 error_propagate(errp, local_err);
726 goto cleanup;
727 }
728
729 ret = bdrv_truncate(qcow_bs, 0);
730 if (ret < 0) {
731 goto exit;
732 }
733
734 memset(&header, 0, sizeof(header));
735 header.magic = cpu_to_be32(QCOW_MAGIC);
736 header.version = cpu_to_be32(QCOW_VERSION);
737 header.size = cpu_to_be64(total_size * 512);
738 header_size = sizeof(header);
739 backing_filename_len = 0;
740 if (backing_file) {
741 if (strcmp(backing_file, "fat:")) {
742 header.backing_file_offset = cpu_to_be64(header_size);
743 backing_filename_len = strlen(backing_file);
744 header.backing_file_size = cpu_to_be32(backing_filename_len);
745 header_size += backing_filename_len;
746 } else {
747 /* special backing file for vvfat */
748 backing_file = NULL;
749 }
750 header.cluster_bits = 9; /* 512 byte cluster to avoid copying
751 unmodified sectors */
752 header.l2_bits = 12; /* 32 KB L2 tables */
753 } else {
754 header.cluster_bits = 12; /* 4 KB clusters */
755 header.l2_bits = 9; /* 4 KB L2 tables */
756 }
757 header_size = (header_size + 7) & ~7;
758 shift = header.cluster_bits + header.l2_bits;
759 l1_size = ((total_size * 512) + (1LL << shift) - 1) >> shift;
760
761 header.l1_table_offset = cpu_to_be64(header_size);
762 if (flags & BLOCK_FLAG_ENCRYPT) {
763 header.crypt_method = cpu_to_be32(QCOW_CRYPT_AES);
764 } else {
765 header.crypt_method = cpu_to_be32(QCOW_CRYPT_NONE);
766 }
767
768 /* write all the data */
769 ret = bdrv_pwrite(qcow_bs, 0, &header, sizeof(header));
770 if (ret != sizeof(header)) {
771 goto exit;
772 }
773
774 if (backing_file) {
775 ret = bdrv_pwrite(qcow_bs, sizeof(header),
776 backing_file, backing_filename_len);
777 if (ret != backing_filename_len) {
778 goto exit;
779 }
780 }
781
782 tmp = g_malloc0(BDRV_SECTOR_SIZE);
783 for (i = 0; i < ((sizeof(uint64_t)*l1_size + BDRV_SECTOR_SIZE - 1)/
784 BDRV_SECTOR_SIZE); i++) {
785 ret = bdrv_pwrite(qcow_bs, header_size +
786 BDRV_SECTOR_SIZE*i, tmp, BDRV_SECTOR_SIZE);
787 if (ret != BDRV_SECTOR_SIZE) {
788 g_free(tmp);
789 goto exit;
790 }
791 }
792
793 g_free(tmp);
794 ret = 0;
795 exit:
796 bdrv_unref(qcow_bs);
797 cleanup:
798 g_free(backing_file);
799 return ret;
800 }
801
802 static int qcow_make_empty(BlockDriverState *bs)
803 {
804 BDRVQcowState *s = bs->opaque;
805 uint32_t l1_length = s->l1_size * sizeof(uint64_t);
806 int ret;
807
808 memset(s->l1_table, 0, l1_length);
809 if (bdrv_pwrite_sync(bs->file, s->l1_table_offset, s->l1_table,
810 l1_length) < 0)
811 return -1;
812 ret = bdrv_truncate(bs->file, s->l1_table_offset + l1_length);
813 if (ret < 0)
814 return ret;
815
816 memset(s->l2_cache, 0, s->l2_size * L2_CACHE_SIZE * sizeof(uint64_t));
817 memset(s->l2_cache_offsets, 0, L2_CACHE_SIZE * sizeof(uint64_t));
818 memset(s->l2_cache_counts, 0, L2_CACHE_SIZE * sizeof(uint32_t));
819
820 return 0;
821 }
822
823 /* XXX: put compressed sectors first, then all the cluster aligned
824 tables to avoid losing bytes in alignment */
825 static int qcow_write_compressed(BlockDriverState *bs, int64_t sector_num,
826 const uint8_t *buf, int nb_sectors)
827 {
828 BDRVQcowState *s = bs->opaque;
829 z_stream strm;
830 int ret, out_len;
831 uint8_t *out_buf;
832 uint64_t cluster_offset;
833
834 if (nb_sectors != s->cluster_sectors) {
835 ret = -EINVAL;
836
837 /* Zero-pad last write if image size is not cluster aligned */
838 if (sector_num + nb_sectors == bs->total_sectors &&
839 nb_sectors < s->cluster_sectors) {
840 uint8_t *pad_buf = qemu_blockalign(bs, s->cluster_size);
841 memset(pad_buf, 0, s->cluster_size);
842 memcpy(pad_buf, buf, nb_sectors * BDRV_SECTOR_SIZE);
843 ret = qcow_write_compressed(bs, sector_num,
844 pad_buf, s->cluster_sectors);
845 qemu_vfree(pad_buf);
846 }
847 return ret;
848 }
849
850 out_buf = g_malloc(s->cluster_size + (s->cluster_size / 1000) + 128);
851
852 /* best compression, small window, no zlib header */
853 memset(&strm, 0, sizeof(strm));
854 ret = deflateInit2(&strm, Z_DEFAULT_COMPRESSION,
855 Z_DEFLATED, -12,
856 9, Z_DEFAULT_STRATEGY);
857 if (ret != 0) {
858 ret = -EINVAL;
859 goto fail;
860 }
861
862 strm.avail_in = s->cluster_size;
863 strm.next_in = (uint8_t *)buf;
864 strm.avail_out = s->cluster_size;
865 strm.next_out = out_buf;
866
867 ret = deflate(&strm, Z_FINISH);
868 if (ret != Z_STREAM_END && ret != Z_OK) {
869 deflateEnd(&strm);
870 ret = -EINVAL;
871 goto fail;
872 }
873 out_len = strm.next_out - out_buf;
874
875 deflateEnd(&strm);
876
877 if (ret != Z_STREAM_END || out_len >= s->cluster_size) {
878 /* could not compress: write normal cluster */
879 ret = bdrv_write(bs, sector_num, buf, s->cluster_sectors);
880 if (ret < 0) {
881 goto fail;
882 }
883 } else {
884 cluster_offset = get_cluster_offset(bs, sector_num << 9, 2,
885 out_len, 0, 0);
886 if (cluster_offset == 0) {
887 ret = -EIO;
888 goto fail;
889 }
890
891 cluster_offset &= s->cluster_offset_mask;
892 ret = bdrv_pwrite(bs->file, cluster_offset, out_buf, out_len);
893 if (ret < 0) {
894 goto fail;
895 }
896 }
897
898 ret = 0;
899 fail:
900 g_free(out_buf);
901 return ret;
902 }
903
904 static int qcow_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
905 {
906 BDRVQcowState *s = bs->opaque;
907 bdi->cluster_size = s->cluster_size;
908 return 0;
909 }
910
911 static QemuOptsList qcow_create_opts = {
912 .name = "qcow-create-opts",
913 .head = QTAILQ_HEAD_INITIALIZER(qcow_create_opts.head),
914 .desc = {
915 {
916 .name = BLOCK_OPT_SIZE,
917 .type = QEMU_OPT_SIZE,
918 .help = "Virtual disk size"
919 },
920 {
921 .name = BLOCK_OPT_BACKING_FILE,
922 .type = QEMU_OPT_STRING,
923 .help = "File name of a base image"
924 },
925 {
926 .name = BLOCK_OPT_ENCRYPT,
927 .type = QEMU_OPT_BOOL,
928 .help = "Encrypt the image",
929 .def_value_str = "off"
930 },
931 { /* end of list */ }
932 }
933 };
934
935 static BlockDriver bdrv_qcow = {
936 .format_name = "qcow",
937 .instance_size = sizeof(BDRVQcowState),
938 .bdrv_probe = qcow_probe,
939 .bdrv_open = qcow_open,
940 .bdrv_close = qcow_close,
941 .bdrv_reopen_prepare = qcow_reopen_prepare,
942 .bdrv_create = qcow_create,
943 .bdrv_has_zero_init = bdrv_has_zero_init_1,
944 .supports_backing = true,
945
946 .bdrv_co_readv = qcow_co_readv,
947 .bdrv_co_writev = qcow_co_writev,
948 .bdrv_co_get_block_status = qcow_co_get_block_status,
949
950 .bdrv_set_key = qcow_set_key,
951 .bdrv_make_empty = qcow_make_empty,
952 .bdrv_write_compressed = qcow_write_compressed,
953 .bdrv_get_info = qcow_get_info,
954
955 .create_opts = &qcow_create_opts,
956 };
957
958 static void bdrv_qcow_init(void)
959 {
960 bdrv_register(&bdrv_qcow);
961 }
962
963 block_init(bdrv_qcow_init);