2 * Block driver for the QCOW version 2 format
4 * Copyright (c) 2004-2006 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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
24 #include "qemu-common.h"
25 #include "block_int.h"
29 #include "block/qcow2.h"
30 #include "qemu-error.h"
34 Differences with QCOW:
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.
40 - Size of compressed clusters is stored in sectors to reduce bit usage
41 in the cluster offsets.
42 - Support for storing additional data (such as the VM state) in the
44 - 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.
54 #define QCOW2_EXT_MAGIC_END 0
55 #define QCOW2_EXT_MAGIC_BACKING_FORMAT 0xE2792ACA
57 static int qcow2_probe(const uint8_t *buf
, int buf_size
, const char *filename
)
59 const QCowHeader
*cow_header
= (const void *)buf
;
61 if (buf_size
>= sizeof(QCowHeader
) &&
62 be32_to_cpu(cow_header
->magic
) == QCOW_MAGIC
&&
63 be32_to_cpu(cow_header
->version
) >= QCOW_VERSION
)
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
77 static int qcow2_read_extensions(BlockDriverState
*bs
, uint64_t start_offset
,
84 printf("qcow2_read_extensions: start=%ld end=%ld\n", start_offset
, end_offset
);
86 offset
= start_offset
;
87 while (offset
< end_offset
) {
91 if (offset
> s
->cluster_size
)
92 printf("qcow2_read_extension: suspicious offset %lu\n", offset
);
94 printf("attemting to read extended header in offset %lu\n", offset
);
97 if (bdrv_pread(bs
->file
, offset
, &ext
, sizeof(ext
)) != sizeof(ext
)) {
98 fprintf(stderr
, "qcow2_read_extension: ERROR: "
99 "pread fail from offset %" PRIu64
"\n",
103 be32_to_cpus(&ext
.magic
);
104 be32_to_cpus(&ext
.len
);
105 offset
+= sizeof(ext
);
107 printf("ext.magic = 0x%x\n", ext
.magic
);
110 case QCOW2_EXT_MAGIC_END
:
113 case QCOW2_EXT_MAGIC_BACKING_FORMAT
:
114 if (ext
.len
>= sizeof(bs
->backing_format
)) {
115 fprintf(stderr
, "ERROR: ext_backing_format: len=%u too large"
117 ext
.len
, sizeof(bs
->backing_format
));
120 if (bdrv_pread(bs
->file
, offset
, bs
->backing_format
,
123 bs
->backing_format
[ext
.len
] = '\0';
125 printf("Qcow2: Got format extension %s\n", bs
->backing_format
);
127 offset
= ((offset
+ ext
.len
+ 7) & ~7);
131 /* unknown magic -- just skip it */
132 offset
= ((offset
+ ext
.len
+ 7) & ~7);
141 static int qcow2_open(BlockDriverState
*bs
, int flags
)
143 BDRVQcowState
*s
= bs
->opaque
;
149 ret
= bdrv_pread(bs
->file
, 0, &header
, sizeof(header
));
153 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
);
167 if (header
.magic
!= QCOW_MAGIC
) {
171 if (header
.version
!= QCOW_VERSION
) {
173 snprintf(version
, sizeof(version
), "QCOW version %d", header
.version
);
174 qerror_report(QERR_UNKNOWN_BLOCK_FORMAT_FEATURE
,
175 bs
->device_name
, "qcow2", version
);
179 if (header
.cluster_bits
< MIN_CLUSTER_BITS
||
180 header
.cluster_bits
> MAX_CLUSTER_BITS
) {
184 if (header
.crypt_method
> QCOW_CRYPT_AES
) {
188 s
->crypt_method_header
= header
.crypt_method
;
189 if (s
->crypt_method_header
) {
192 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
;
202 s
->refcount_table_size
=
203 header
.refcount_table_clusters
<< (s
->cluster_bits
- 3);
205 s
->snapshots_offset
= header
.snapshots_offset
;
206 s
->nb_snapshots
= header
.nb_snapshots
;
208 /* read the level 1 table */
209 s
->l1_size
= header
.l1_size
;
210 s
->l1_vm_state_index
= size_to_l1(s
, header
.size
);
211 /* the L1 table must contain at least enough entries to put
213 if (s
->l1_size
< s
->l1_vm_state_index
) {
217 s
->l1_table_offset
= header
.l1_table_offset
;
218 if (s
->l1_size
> 0) {
219 s
->l1_table
= qemu_mallocz(
220 align_offset(s
->l1_size
* sizeof(uint64_t), 512));
221 ret
= bdrv_pread(bs
->file
, s
->l1_table_offset
, s
->l1_table
,
222 s
->l1_size
* sizeof(uint64_t));
226 for(i
= 0;i
< s
->l1_size
; i
++) {
227 be64_to_cpus(&s
->l1_table
[i
]);
231 /* alloc L2 table/refcount block cache */
232 writethrough
= ((flags
& BDRV_O_CACHE_WB
) == 0);
233 s
->l2_table_cache
= qcow2_cache_create(bs
, L2_CACHE_SIZE
, writethrough
);
234 s
->refcount_block_cache
= qcow2_cache_create(bs
, REFCOUNT_CACHE_SIZE
,
237 s
->cluster_cache
= qemu_malloc(s
->cluster_size
);
238 /* one more sector for decompressed data alignment */
239 s
->cluster_data
= qemu_malloc(QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
241 s
->cluster_cache_offset
= -1;
243 ret
= qcow2_refcount_init(bs
);
248 QLIST_INIT(&s
->cluster_allocs
);
250 /* read qcow2 extensions */
251 if (header
.backing_file_offset
) {
252 ext_end
= header
.backing_file_offset
;
254 ext_end
= s
->cluster_size
;
256 if (qcow2_read_extensions(bs
, sizeof(header
), ext_end
)) {
261 /* read the backing file name */
262 if (header
.backing_file_offset
!= 0) {
263 len
= header
.backing_file_size
;
267 ret
= bdrv_pread(bs
->file
, header
.backing_file_offset
,
268 bs
->backing_file
, len
);
272 bs
->backing_file
[len
] = '\0';
274 if (qcow2_read_snapshots(bs
) < 0) {
280 qcow2_check_refcounts(bs
);
285 qcow2_free_snapshots(bs
);
286 qcow2_refcount_close(bs
);
287 qemu_free(s
->l1_table
);
288 if (s
->l2_table_cache
) {
289 qcow2_cache_destroy(bs
, s
->l2_table_cache
);
291 qemu_free(s
->cluster_cache
);
292 qemu_free(s
->cluster_data
);
296 static int qcow2_set_key(BlockDriverState
*bs
, const char *key
)
298 BDRVQcowState
*s
= bs
->opaque
;
302 memset(keybuf
, 0, 16);
306 /* XXX: we could compress the chars to 7 bits to increase
308 for(i
= 0;i
< len
;i
++) {
311 s
->crypt_method
= s
->crypt_method_header
;
313 if (AES_set_encrypt_key(keybuf
, 128, &s
->aes_encrypt_key
) != 0)
315 if (AES_set_decrypt_key(keybuf
, 128, &s
->aes_decrypt_key
) != 0)
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
]);
330 for(i
= 0; i
< 16; i
++)
331 printf(" %02x", out
[i
]);
338 static int qcow2_is_allocated(BlockDriverState
*bs
, int64_t sector_num
,
339 int nb_sectors
, int *pnum
)
341 uint64_t cluster_offset
;
345 /* 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
);
352 return (cluster_offset
!= 0);
355 /* handle reading after the end of the backing file */
356 int qcow2_backing_read1(BlockDriverState
*bs
, QEMUIOVector
*qiov
,
357 int64_t sector_num
, int nb_sectors
)
360 if ((sector_num
+ nb_sectors
) <= bs
->total_sectors
)
362 if (sector_num
>= bs
->total_sectors
)
365 n1
= bs
->total_sectors
- sector_num
;
367 qemu_iovec_memset_skip(qiov
, 0, 512 * (nb_sectors
- n1
), 512 * n1
);
372 typedef struct QCowAIOCB
{
373 BlockDriverAIOCB common
;
376 int remaining_sectors
;
377 int cur_nr_sectors
; /* number of sectors in current iteration */
379 uint64_t cluster_offset
;
380 uint8_t *cluster_data
;
382 BlockDriverAIOCB
*hd_aiocb
;
383 QEMUIOVector hd_qiov
;
386 QLIST_ENTRY(QCowAIOCB
) next_depend
;
389 static void qcow2_aio_cancel(BlockDriverAIOCB
*blockacb
)
391 QCowAIOCB
*acb
= container_of(blockacb
, QCowAIOCB
, common
);
393 bdrv_aio_cancel(acb
->hd_aiocb
);
394 qemu_aio_release(acb
);
397 static AIOPool qcow2_aio_pool
= {
398 .aiocb_size
= sizeof(QCowAIOCB
),
399 .cancel
= qcow2_aio_cancel
,
402 static void qcow2_aio_read_cb(void *opaque
, int ret
);
403 static void qcow2_aio_write_cb(void *opaque
, int ret
);
405 static void qcow2_aio_rw_bh(void *opaque
)
407 QCowAIOCB
*acb
= opaque
;
408 qemu_bh_delete(acb
->bh
);
412 qcow2_aio_write_cb(opaque
, 0);
414 qcow2_aio_read_cb(opaque
, 0);
418 static int qcow2_schedule_bh(QEMUBHFunc
*cb
, QCowAIOCB
*acb
)
423 acb
->bh
= qemu_bh_new(cb
, acb
);
427 qemu_bh_schedule(acb
->bh
);
432 static void qcow2_aio_read_cb(void *opaque
, int ret
)
434 QCowAIOCB
*acb
= opaque
;
435 BlockDriverState
*bs
= acb
->common
.bs
;
436 BDRVQcowState
*s
= bs
->opaque
;
437 int index_in_cluster
, n1
;
439 acb
->hd_aiocb
= NULL
;
443 /* post process the read buffer */
444 if (!acb
->cluster_offset
) {
446 } else if (acb
->cluster_offset
& QCOW_OFLAG_COMPRESSED
) {
449 if (s
->crypt_method
) {
450 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
);
460 acb
->remaining_sectors
-= acb
->cur_nr_sectors
;
461 acb
->sector_num
+= acb
->cur_nr_sectors
;
462 acb
->bytes_done
+= acb
->cur_nr_sectors
* 512;
464 if (acb
->remaining_sectors
== 0) {
465 /* request completed */
470 /* prepare next AIO request */
471 acb
->cur_nr_sectors
= acb
->remaining_sectors
;
472 if (s
->crypt_method
) {
473 acb
->cur_nr_sectors
= MIN(acb
->cur_nr_sectors
,
474 QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_sectors
);
477 ret
= qcow2_get_cluster_offset(bs
, acb
->sector_num
<< 9,
478 &acb
->cur_nr_sectors
, &acb
->cluster_offset
);
483 index_in_cluster
= acb
->sector_num
& (s
->cluster_sectors
- 1);
485 qemu_iovec_reset(&acb
->hd_qiov
);
486 qemu_iovec_copy(&acb
->hd_qiov
, acb
->qiov
, acb
->bytes_done
,
487 acb
->cur_nr_sectors
* 512);
489 if (!acb
->cluster_offset
) {
491 if (bs
->backing_hd
) {
492 /* read from the base image */
493 n1
= qcow2_backing_read1(bs
->backing_hd
, &acb
->hd_qiov
,
494 acb
->sector_num
, acb
->cur_nr_sectors
);
496 BLKDBG_EVENT(bs
->file
, BLKDBG_READ_BACKING_AIO
);
497 acb
->hd_aiocb
= bdrv_aio_readv(bs
->backing_hd
, acb
->sector_num
,
498 &acb
->hd_qiov
, n1
, qcow2_aio_read_cb
, acb
);
499 if (acb
->hd_aiocb
== NULL
) {
504 ret
= qcow2_schedule_bh(qcow2_aio_rw_bh
, acb
);
509 /* Note: in this case, no need to wait */
510 qemu_iovec_memset(&acb
->hd_qiov
, 0, 512 * acb
->cur_nr_sectors
);
511 ret
= qcow2_schedule_bh(qcow2_aio_rw_bh
, acb
);
515 } else if (acb
->cluster_offset
& QCOW_OFLAG_COMPRESSED
) {
516 /* add AIO support for compressed blocks ? */
517 ret
= qcow2_decompress_cluster(bs
, acb
->cluster_offset
);
522 qemu_iovec_from_buffer(&acb
->hd_qiov
,
523 s
->cluster_cache
+ index_in_cluster
* 512,
524 512 * acb
->cur_nr_sectors
);
526 ret
= qcow2_schedule_bh(qcow2_aio_rw_bh
, acb
);
530 if ((acb
->cluster_offset
& 511) != 0) {
535 if (s
->crypt_method
) {
537 * For encrypted images, read everything into a temporary
538 * contiguous buffer on which the AES functions can work.
540 if (!acb
->cluster_data
) {
542 qemu_mallocz(QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
);
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
);
552 BLKDBG_EVENT(bs
->file
, BLKDBG_READ_AIO
);
553 acb
->hd_aiocb
= bdrv_aio_readv(bs
->file
,
554 (acb
->cluster_offset
>> 9) + index_in_cluster
,
555 &acb
->hd_qiov
, acb
->cur_nr_sectors
,
556 qcow2_aio_read_cb
, acb
);
557 if (acb
->hd_aiocb
== NULL
) {
565 acb
->common
.cb(acb
->common
.opaque
, ret
);
566 qemu_iovec_destroy(&acb
->hd_qiov
);
567 qemu_aio_release(acb
);
570 static 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
)
577 acb
= qemu_aio_get(&qcow2_aio_pool
, bs
, cb
, opaque
);
580 acb
->hd_aiocb
= NULL
;
581 acb
->sector_num
= sector_num
;
583 acb
->is_write
= is_write
;
585 qemu_iovec_init(&acb
->hd_qiov
, qiov
->niov
);
588 acb
->remaining_sectors
= nb_sectors
;
589 acb
->cur_nr_sectors
= 0;
590 acb
->cluster_offset
= 0;
591 acb
->l2meta
.nb_clusters
= 0;
592 QLIST_INIT(&acb
->l2meta
.dependent_requests
);
596 static BlockDriverAIOCB
*qcow2_aio_readv(BlockDriverState
*bs
,
598 QEMUIOVector
*qiov
, int nb_sectors
,
599 BlockDriverCompletionFunc
*cb
,
605 acb
= qcow2_aio_setup(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 0);
609 ret
= qcow2_schedule_bh(qcow2_aio_rw_bh
, acb
);
611 qemu_iovec_destroy(&acb
->hd_qiov
);
612 qemu_aio_release(acb
);
619 static void run_dependent_requests(QCowL2Meta
*m
)
624 /* Take the request off the list of running requests */
625 if (m
->nb_clusters
!= 0) {
626 QLIST_REMOVE(m
, next_in_flight
);
629 /* Restart all dependent requests */
630 QLIST_FOREACH_SAFE(req
, &m
->dependent_requests
, next_depend
, next
) {
631 qcow2_aio_write_cb(req
, 0);
634 /* Empty the list for the next part of the request */
635 QLIST_INIT(&m
->dependent_requests
);
638 static void qcow2_aio_write_cb(void *opaque
, int ret
)
640 QCowAIOCB
*acb
= opaque
;
641 BlockDriverState
*bs
= acb
->common
.bs
;
642 BDRVQcowState
*s
= bs
->opaque
;
643 int index_in_cluster
;
646 acb
->hd_aiocb
= NULL
;
649 ret
= qcow2_alloc_cluster_link_l2(bs
, &acb
->l2meta
);
652 run_dependent_requests(&acb
->l2meta
);
657 acb
->remaining_sectors
-= acb
->cur_nr_sectors
;
658 acb
->sector_num
+= acb
->cur_nr_sectors
;
659 acb
->bytes_done
+= acb
->cur_nr_sectors
* 512;
661 if (acb
->remaining_sectors
== 0) {
662 /* request completed */
667 index_in_cluster
= acb
->sector_num
& (s
->cluster_sectors
- 1);
668 n_end
= index_in_cluster
+ acb
->remaining_sectors
;
669 if (s
->crypt_method
&&
670 n_end
> QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_sectors
)
671 n_end
= QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_sectors
;
673 ret
= qcow2_alloc_cluster_offset(bs
, acb
->sector_num
<< 9,
674 index_in_cluster
, n_end
, &acb
->cur_nr_sectors
, &acb
->l2meta
);
679 acb
->cluster_offset
= acb
->l2meta
.cluster_offset
;
681 /* Need to wait for another request? If so, we are done for now. */
682 if (acb
->l2meta
.nb_clusters
== 0 && acb
->l2meta
.depends_on
!= NULL
) {
683 QLIST_INSERT_HEAD(&acb
->l2meta
.depends_on
->dependent_requests
,
688 assert((acb
->cluster_offset
& 511) == 0);
690 qemu_iovec_reset(&acb
->hd_qiov
);
691 qemu_iovec_copy(&acb
->hd_qiov
, acb
->qiov
, acb
->bytes_done
,
692 acb
->cur_nr_sectors
* 512);
694 if (s
->crypt_method
) {
695 if (!acb
->cluster_data
) {
696 acb
->cluster_data
= qemu_mallocz(QCOW_MAX_CRYPT_CLUSTERS
*
700 assert(acb
->hd_qiov
.size
<= QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
);
701 qemu_iovec_to_buffer(&acb
->hd_qiov
, acb
->cluster_data
);
703 qcow2_encrypt_sectors(s
, acb
->sector_num
, acb
->cluster_data
,
704 acb
->cluster_data
, acb
->cur_nr_sectors
, 1, &s
->aes_encrypt_key
);
706 qemu_iovec_reset(&acb
->hd_qiov
);
707 qemu_iovec_add(&acb
->hd_qiov
, acb
->cluster_data
,
708 acb
->cur_nr_sectors
* 512);
711 BLKDBG_EVENT(bs
->file
, BLKDBG_WRITE_AIO
);
712 acb
->hd_aiocb
= bdrv_aio_writev(bs
->file
,
713 (acb
->cluster_offset
>> 9) + index_in_cluster
,
714 &acb
->hd_qiov
, acb
->cur_nr_sectors
,
715 qcow2_aio_write_cb
, acb
);
716 if (acb
->hd_aiocb
== NULL
) {
724 if (acb
->l2meta
.nb_clusters
!= 0) {
725 QLIST_REMOVE(&acb
->l2meta
, next_in_flight
);
728 acb
->common
.cb(acb
->common
.opaque
, ret
);
729 qemu_iovec_destroy(&acb
->hd_qiov
);
730 qemu_aio_release(acb
);
733 static BlockDriverAIOCB
*qcow2_aio_writev(BlockDriverState
*bs
,
735 QEMUIOVector
*qiov
, int nb_sectors
,
736 BlockDriverCompletionFunc
*cb
,
739 BDRVQcowState
*s
= bs
->opaque
;
743 s
->cluster_cache_offset
= -1; /* disable compressed cache */
745 acb
= qcow2_aio_setup(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 1);
749 ret
= qcow2_schedule_bh(qcow2_aio_rw_bh
, acb
);
751 qemu_iovec_destroy(&acb
->hd_qiov
);
752 qemu_aio_release(acb
);
759 static void qcow2_close(BlockDriverState
*bs
)
761 BDRVQcowState
*s
= bs
->opaque
;
762 qemu_free(s
->l1_table
);
764 qcow2_cache_flush(bs
, s
->l2_table_cache
);
765 qcow2_cache_flush(bs
, s
->refcount_block_cache
);
767 qcow2_cache_destroy(bs
, s
->l2_table_cache
);
768 qcow2_cache_destroy(bs
, s
->refcount_block_cache
);
770 qemu_free(s
->cluster_cache
);
771 qemu_free(s
->cluster_data
);
772 qcow2_refcount_close(bs
);
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
781 * Returns 0 on success, -errno in error cases.
783 static int qcow2_update_ext_header(BlockDriverState
*bs
,
784 const char *backing_file
, const char *backing_fmt
)
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};
792 /* Backing file format doesn't make sense without a backing file */
793 if (backing_fmt
&& !backing_file
) {
797 /* Prepare the backing file format extension if needed */
799 ext_backing_fmt
.len
= cpu_to_be32(strlen(backing_fmt
));
800 ext_backing_fmt
.magic
= cpu_to_be32(QCOW2_EXT_MAGIC_BACKING_FORMAT
);
801 backing_fmt_len
= ((sizeof(ext_backing_fmt
)
802 + strlen(backing_fmt
) + 7) & ~7);
805 /* Check if we can fit the new header into the first cluster */
807 backing_file_len
= strlen(backing_file
);
810 size_t header_size
= sizeof(QCowHeader
) + backing_file_len
813 if (header_size
> s
->cluster_size
) {
817 /* Rewrite backing file name and qcow2 extensions */
818 size_t ext_size
= header_size
- sizeof(QCowHeader
);
819 uint8_t buf
[ext_size
];
821 size_t backing_file_offset
= 0;
825 int padding
= backing_fmt_len
-
826 (sizeof(ext_backing_fmt
) + strlen(backing_fmt
));
828 memcpy(buf
+ offset
, &ext_backing_fmt
, sizeof(ext_backing_fmt
));
829 offset
+= sizeof(ext_backing_fmt
);
831 memcpy(buf
+ offset
, backing_fmt
, strlen(backing_fmt
));
832 offset
+= strlen(backing_fmt
);
834 memset(buf
+ offset
, 0, padding
);
838 memcpy(buf
+ offset
, backing_file
, backing_file_len
);
839 backing_file_offset
= sizeof(QCowHeader
) + offset
;
842 ret
= bdrv_pwrite_sync(bs
->file
, sizeof(QCowHeader
), buf
, ext_size
);
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
);
851 ret
= bdrv_pwrite_sync(bs
->file
, offsetof(QCowHeader
, backing_file_offset
),
852 &be_backing_file_offset
, sizeof(uint64_t));
857 ret
= bdrv_pwrite_sync(bs
->file
, offsetof(QCowHeader
, backing_file_size
),
858 &be_backing_file_size
, sizeof(uint32_t));
868 static int qcow2_change_backing_file(BlockDriverState
*bs
,
869 const char *backing_file
, const char *backing_fmt
)
871 return qcow2_update_ext_header(bs
, backing_file
, backing_fmt
);
874 static int preallocate(BlockDriverState
*bs
)
882 nb_sectors
= bdrv_getlength(bs
) >> 9;
884 QLIST_INIT(&meta
.dependent_requests
);
885 meta
.cluster_offset
= 0;
888 num
= MIN(nb_sectors
, INT_MAX
>> 9);
889 ret
= qcow2_alloc_cluster_offset(bs
, offset
, 0, num
, &num
, &meta
);
894 ret
= qcow2_alloc_cluster_link_l2(bs
, &meta
);
896 qcow2_free_any_clusters(bs
, meta
.cluster_offset
, meta
.nb_clusters
);
900 /* 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
);
904 /* TODO Preallocate data if requested */
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.
915 if (meta
.cluster_offset
!= 0) {
918 ret
= bdrv_write(bs
->file
, (meta
.cluster_offset
>> 9) + num
- 1, buf
, 1);
927 static 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
)
932 /* Calulate 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
)
939 "Cluster size must be a power of two between %d and %dk",
940 1 << MIN_CLUSTER_BITS
, 1 << (MAX_CLUSTER_BITS
- 10));
945 * Open the image file and write a minimal qcow2 header.
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.
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.
956 BlockDriverState
* bs
;
958 uint8_t* refcount_table
;
961 ret
= bdrv_create_file(filename
, options
);
966 ret
= bdrv_file_open(&bs
, filename
, BDRV_O_RDWR
);
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);
982 if (flags
& BLOCK_FLAG_ENCRYPT
) {
983 header
.crypt_method
= cpu_to_be32(QCOW_CRYPT_AES
);
985 header
.crypt_method
= cpu_to_be32(QCOW_CRYPT_NONE
);
988 ret
= bdrv_pwrite(bs
, 0, &header
, sizeof(header
));
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
);
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
1009 BlockDriver
* drv
= bdrv_find_format("qcow2");
1010 assert(drv
!= NULL
);
1011 ret
= bdrv_open(bs
, filename
,
1012 BDRV_O_RDWR
| BDRV_O_CACHE_WB
| BDRV_O_NO_FLUSH
, drv
);
1017 ret
= qcow2_alloc_clusters(bs
, 2 * cluster_size
);
1021 } else if (ret
!= 0) {
1022 error_report("Huh, first cluster in empty image is already in use?");
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
);
1032 /* Want a backing file? There you go.*/
1034 ret
= bdrv_change_backing_file(bs
, backing_file
, backing_format
);
1040 /* And if we're supposed to preallocate metadata, do that now */
1042 ret
= preallocate(bs
);
1054 static int qcow2_create(const char *filename
, QEMUOptionParameter
*options
)
1056 const char *backing_file
= NULL
;
1057 const char *backing_fmt
= NULL
;
1058 uint64_t sectors
= 0;
1060 size_t cluster_size
= DEFAULT_CLUSTER_SIZE
;
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
;
1077 } else if (!strcmp(options
->name
, BLOCK_OPT_PREALLOC
)) {
1078 if (!options
->value
.s
|| !strcmp(options
->value
.s
, "off")) {
1080 } else if (!strcmp(options
->value
.s
, "metadata")) {
1083 fprintf(stderr
, "Invalid preallocation mode: '%s'\n",
1091 if (backing_file
&& prealloc
) {
1092 fprintf(stderr
, "Backing file and preallocation cannot be used at "
1097 return qcow2_create2(filename
, sectors
, backing_file
, backing_fmt
, flags
,
1098 cluster_size
, prealloc
, options
);
1101 static int qcow2_make_empty(BlockDriverState
*bs
)
1104 /* XXX: not correct */
1105 BDRVQcowState
*s
= bs
->opaque
;
1106 uint32_t l1_length
= s
->l1_size
* sizeof(uint64_t);
1109 memset(s
->l1_table
, 0, l1_length
);
1110 if (bdrv_pwrite(bs
->file
, s
->l1_table_offset
, s
->l1_table
, l1_length
) < 0)
1112 ret
= bdrv_truncate(bs
->file
, s
->l1_table_offset
+ l1_length
);
1121 static int qcow2_discard(BlockDriverState
*bs
, int64_t sector_num
,
1124 return qcow2_discard_clusters(bs
, sector_num
<< BDRV_SECTOR_BITS
,
1128 static int qcow2_truncate(BlockDriverState
*bs
, int64_t offset
)
1130 BDRVQcowState
*s
= bs
->opaque
;
1131 int ret
, new_l1_size
;
1137 /* cannot proceed if image has snapshots */
1138 if (s
->nb_snapshots
) {
1142 /* shrinking is currently not supported */
1143 if (offset
< bs
->total_sectors
* 512) {
1147 new_l1_size
= size_to_l1(s
, offset
);
1148 ret
= qcow2_grow_l1_table(bs
, new_l1_size
, true);
1153 /* write updated header.size */
1154 offset
= cpu_to_be64(offset
);
1155 ret
= bdrv_pwrite_sync(bs
->file
, offsetof(QCowHeader
, size
),
1156 &offset
, sizeof(uint64_t));
1161 s
->l1_vm_state_index
= new_l1_size
;
1165 /* XXX: put compressed sectors first, then all the cluster aligned
1166 tables to avoid losing bytes in alignment */
1167 static int qcow2_write_compressed(BlockDriverState
*bs
, int64_t sector_num
,
1168 const uint8_t *buf
, int nb_sectors
)
1170 BDRVQcowState
*s
= bs
->opaque
;
1174 uint64_t cluster_offset
;
1176 if (nb_sectors
== 0) {
1177 /* align end of file to a sector boundary to ease reading with
1178 sector based I/Os */
1179 cluster_offset
= bdrv_getlength(bs
->file
);
1180 cluster_offset
= (cluster_offset
+ 511) & ~511;
1181 bdrv_truncate(bs
->file
, cluster_offset
);
1185 if (nb_sectors
!= s
->cluster_sectors
)
1188 out_buf
= qemu_malloc(s
->cluster_size
+ (s
->cluster_size
/ 1000) + 128);
1190 /* best compression, small window, no zlib header */
1191 memset(&strm
, 0, sizeof(strm
));
1192 ret
= deflateInit2(&strm
, Z_DEFAULT_COMPRESSION
,
1194 9, Z_DEFAULT_STRATEGY
);
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
;
1205 ret
= deflate(&strm
, Z_FINISH
);
1206 if (ret
!= Z_STREAM_END
&& ret
!= Z_OK
) {
1211 out_len
= strm
.next_out
- out_buf
;
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
);
1219 cluster_offset
= qcow2_alloc_compressed_cluster_offset(bs
,
1220 sector_num
<< 9, out_len
);
1221 if (!cluster_offset
)
1223 cluster_offset
&= s
->cluster_offset_mask
;
1224 BLKDBG_EVENT(bs
->file
, BLKDBG_WRITE_COMPRESSED
);
1225 if (bdrv_pwrite(bs
->file
, cluster_offset
, out_buf
, out_len
) != out_len
) {
1235 static int qcow2_flush(BlockDriverState
*bs
)
1237 BDRVQcowState
*s
= bs
->opaque
;
1240 ret
= qcow2_cache_flush(bs
, s
->l2_table_cache
);
1245 ret
= qcow2_cache_flush(bs
, s
->refcount_block_cache
);
1250 return bdrv_flush(bs
->file
);
1253 static BlockDriverAIOCB
*qcow2_aio_flush(BlockDriverState
*bs
,
1254 BlockDriverCompletionFunc
*cb
,
1257 BDRVQcowState
*s
= bs
->opaque
;
1260 ret
= qcow2_cache_flush(bs
, s
->l2_table_cache
);
1265 ret
= qcow2_cache_flush(bs
, s
->refcount_block_cache
);
1270 return bdrv_aio_flush(bs
->file
, cb
, opaque
);
1273 static int64_t qcow2_vm_state_offset(BDRVQcowState
*s
)
1275 return (int64_t)s
->l1_vm_state_index
<< (s
->cluster_bits
+ s
->l2_bits
);
1278 static int qcow2_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
1280 BDRVQcowState
*s
= bs
->opaque
;
1281 bdi
->cluster_size
= s
->cluster_size
;
1282 bdi
->vm_state_offset
= qcow2_vm_state_offset(s
);
1287 static int qcow2_check(BlockDriverState
*bs
, BdrvCheckResult
*result
)
1289 return qcow2_check_refcounts(bs
, result
);
1293 static void dump_refcounts(BlockDriverState
*bs
)
1295 BDRVQcowState
*s
= bs
->opaque
;
1296 int64_t nb_clusters
, k
, k1
, size
;
1299 size
= bdrv_getlength(bs
->file
);
1300 nb_clusters
= size_to_clusters(s
, size
);
1301 for(k
= 0; k
< nb_clusters
;) {
1303 refcount
= get_refcount(bs
, k
);
1305 while (k
< nb_clusters
&& get_refcount(bs
, k
) == refcount
)
1307 printf("%" PRId64
": refcount=%d nb=%" PRId64
"\n", k
, refcount
,
1313 static int qcow2_save_vmstate(BlockDriverState
*bs
, const uint8_t *buf
,
1314 int64_t pos
, int size
)
1316 BDRVQcowState
*s
= bs
->opaque
;
1317 int growable
= bs
->growable
;
1320 BLKDBG_EVENT(bs
->file
, BLKDBG_VMSTATE_SAVE
);
1322 ret
= bdrv_pwrite(bs
, qcow2_vm_state_offset(s
) + pos
, buf
, size
);
1323 bs
->growable
= growable
;
1328 static int qcow2_load_vmstate(BlockDriverState
*bs
, uint8_t *buf
,
1329 int64_t pos
, int size
)
1331 BDRVQcowState
*s
= bs
->opaque
;
1332 int growable
= bs
->growable
;
1335 BLKDBG_EVENT(bs
->file
, BLKDBG_VMSTATE_LOAD
);
1337 ret
= bdrv_pread(bs
, qcow2_vm_state_offset(s
) + pos
, buf
, size
);
1338 bs
->growable
= growable
;
1343 static QEMUOptionParameter qcow2_create_options
[] = {
1345 .name
= BLOCK_OPT_SIZE
,
1347 .help
= "Virtual disk size"
1350 .name
= BLOCK_OPT_BACKING_FILE
,
1352 .help
= "File name of a base image"
1355 .name
= BLOCK_OPT_BACKING_FMT
,
1357 .help
= "Image format of the base image"
1360 .name
= BLOCK_OPT_ENCRYPT
,
1362 .help
= "Encrypt the image"
1365 .name
= BLOCK_OPT_CLUSTER_SIZE
,
1367 .help
= "qcow2 cluster size",
1368 .value
= { .n
= DEFAULT_CLUSTER_SIZE
},
1371 .name
= BLOCK_OPT_PREALLOC
,
1373 .help
= "Preallocation mode (allowed values: off, metadata)"
1378 static BlockDriver bdrv_qcow2
= {
1379 .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
,
1390 .bdrv_aio_readv
= qcow2_aio_readv
,
1391 .bdrv_aio_writev
= qcow2_aio_writev
,
1392 .bdrv_aio_flush
= qcow2_aio_flush
,
1394 .bdrv_discard
= qcow2_discard
,
1395 .bdrv_truncate
= qcow2_truncate
,
1396 .bdrv_write_compressed
= qcow2_write_compressed
,
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
,
1402 .bdrv_snapshot_load_tmp
= qcow2_snapshot_load_tmp
,
1403 .bdrv_get_info
= qcow2_get_info
,
1405 .bdrv_save_vmstate
= qcow2_save_vmstate
,
1406 .bdrv_load_vmstate
= qcow2_load_vmstate
,
1408 .bdrv_change_backing_file
= qcow2_change_backing_file
,
1410 .create_options
= qcow2_create_options
,
1411 .bdrv_check
= qcow2_check
,
1414 static void bdrv_qcow2_init(void)
1416 bdrv_register(&bdrv_qcow2
);
1419 block_init(bdrv_qcow2_init
);