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"
32 Differences with QCOW:
34 - Support for multiple incremental snapshots.
35 - Memory management by reference counts.
36 - Clusters which have a reference count of one have the bit
37 QCOW_OFLAG_COPIED to optimize write performance.
38 - Size of compressed clusters is stored in sectors to reduce bit usage
39 in the cluster offsets.
40 - Support for storing additional data (such as the VM state) in the
42 - If a backing store is used, the cluster size is not constrained
43 (could be backported to QCOW).
44 - L2 tables have always a size of one cluster.
52 #define QCOW_EXT_MAGIC_END 0
53 #define QCOW_EXT_MAGIC_BACKING_FORMAT 0xE2792ACA
55 static int qcow_create(const char *filename
, QEMUOptionParameter
*options
);
57 static int qcow_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 qcow_read_extensions(BlockDriverState
*bs
, uint64_t start_offset
,
84 printf("qcow_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("qcow_handle_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
, "qcow_handle_extension: ERROR: pread fail from offset %llu\n",
99 (unsigned long long)offset
);
102 be32_to_cpus(&ext
.magic
);
103 be32_to_cpus(&ext
.len
);
104 offset
+= sizeof(ext
);
106 printf("ext.magic = 0x%x\n", ext
.magic
);
109 case QCOW_EXT_MAGIC_END
:
112 case QCOW_EXT_MAGIC_BACKING_FORMAT
:
113 if (ext
.len
>= sizeof(bs
->backing_format
)) {
114 fprintf(stderr
, "ERROR: ext_backing_format: len=%u too large"
116 ext
.len
, sizeof(bs
->backing_format
));
119 if (bdrv_pread(bs
->file
, offset
, bs
->backing_format
,
122 bs
->backing_format
[ext
.len
] = '\0';
124 printf("Qcow2: Got format extension %s\n", bs
->backing_format
);
126 offset
= ((offset
+ ext
.len
+ 7) & ~7);
130 /* unknown magic -- just skip it */
131 offset
= ((offset
+ ext
.len
+ 7) & ~7);
140 static int qcow_open(BlockDriverState
*bs
, int flags
)
142 BDRVQcowState
*s
= bs
->opaque
;
147 if (bdrv_pread(bs
->file
, 0, &header
, sizeof(header
)) != sizeof(header
))
149 be32_to_cpus(&header
.magic
);
150 be32_to_cpus(&header
.version
);
151 be64_to_cpus(&header
.backing_file_offset
);
152 be32_to_cpus(&header
.backing_file_size
);
153 be64_to_cpus(&header
.size
);
154 be32_to_cpus(&header
.cluster_bits
);
155 be32_to_cpus(&header
.crypt_method
);
156 be64_to_cpus(&header
.l1_table_offset
);
157 be32_to_cpus(&header
.l1_size
);
158 be64_to_cpus(&header
.refcount_table_offset
);
159 be32_to_cpus(&header
.refcount_table_clusters
);
160 be64_to_cpus(&header
.snapshots_offset
);
161 be32_to_cpus(&header
.nb_snapshots
);
163 if (header
.magic
!= QCOW_MAGIC
|| header
.version
!= QCOW_VERSION
)
165 if (header
.cluster_bits
< MIN_CLUSTER_BITS
||
166 header
.cluster_bits
> MAX_CLUSTER_BITS
)
168 if (header
.crypt_method
> QCOW_CRYPT_AES
)
170 s
->crypt_method_header
= header
.crypt_method
;
171 if (s
->crypt_method_header
)
173 s
->cluster_bits
= header
.cluster_bits
;
174 s
->cluster_size
= 1 << s
->cluster_bits
;
175 s
->cluster_sectors
= 1 << (s
->cluster_bits
- 9);
176 s
->l2_bits
= s
->cluster_bits
- 3; /* L2 is always one cluster */
177 s
->l2_size
= 1 << s
->l2_bits
;
178 bs
->total_sectors
= header
.size
/ 512;
179 s
->csize_shift
= (62 - (s
->cluster_bits
- 8));
180 s
->csize_mask
= (1 << (s
->cluster_bits
- 8)) - 1;
181 s
->cluster_offset_mask
= (1LL << s
->csize_shift
) - 1;
182 s
->refcount_table_offset
= header
.refcount_table_offset
;
183 s
->refcount_table_size
=
184 header
.refcount_table_clusters
<< (s
->cluster_bits
- 3);
186 s
->snapshots_offset
= header
.snapshots_offset
;
187 s
->nb_snapshots
= header
.nb_snapshots
;
189 /* read the level 1 table */
190 s
->l1_size
= header
.l1_size
;
191 shift
= s
->cluster_bits
+ s
->l2_bits
;
192 s
->l1_vm_state_index
= (header
.size
+ (1LL << shift
) - 1) >> shift
;
193 /* the L1 table must contain at least enough entries to put
195 if (s
->l1_size
< s
->l1_vm_state_index
)
197 s
->l1_table_offset
= header
.l1_table_offset
;
198 if (s
->l1_size
> 0) {
199 s
->l1_table
= qemu_mallocz(
200 align_offset(s
->l1_size
* sizeof(uint64_t), 512));
201 if (bdrv_pread(bs
->file
, s
->l1_table_offset
, s
->l1_table
, s
->l1_size
* sizeof(uint64_t)) !=
202 s
->l1_size
* sizeof(uint64_t))
204 for(i
= 0;i
< s
->l1_size
; i
++) {
205 be64_to_cpus(&s
->l1_table
[i
]);
209 s
->l2_cache
= qemu_malloc(s
->l2_size
* L2_CACHE_SIZE
* sizeof(uint64_t));
210 s
->cluster_cache
= qemu_malloc(s
->cluster_size
);
211 /* one more sector for decompressed data alignment */
212 s
->cluster_data
= qemu_malloc(QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
214 s
->cluster_cache_offset
= -1;
216 if (qcow2_refcount_init(bs
) < 0)
219 QLIST_INIT(&s
->cluster_allocs
);
221 /* read qcow2 extensions */
222 if (header
.backing_file_offset
)
223 ext_end
= header
.backing_file_offset
;
225 ext_end
= s
->cluster_size
;
226 if (qcow_read_extensions(bs
, sizeof(header
), ext_end
))
229 /* read the backing file name */
230 if (header
.backing_file_offset
!= 0) {
231 len
= header
.backing_file_size
;
234 if (bdrv_pread(bs
->file
, header
.backing_file_offset
, bs
->backing_file
, len
) != len
)
236 bs
->backing_file
[len
] = '\0';
238 if (qcow2_read_snapshots(bs
) < 0)
242 qcow2_check_refcounts(bs
);
247 qcow2_free_snapshots(bs
);
248 qcow2_refcount_close(bs
);
249 qemu_free(s
->l1_table
);
250 qemu_free(s
->l2_cache
);
251 qemu_free(s
->cluster_cache
);
252 qemu_free(s
->cluster_data
);
256 static int qcow_set_key(BlockDriverState
*bs
, const char *key
)
258 BDRVQcowState
*s
= bs
->opaque
;
262 memset(keybuf
, 0, 16);
266 /* XXX: we could compress the chars to 7 bits to increase
268 for(i
= 0;i
< len
;i
++) {
271 s
->crypt_method
= s
->crypt_method_header
;
273 if (AES_set_encrypt_key(keybuf
, 128, &s
->aes_encrypt_key
) != 0)
275 if (AES_set_decrypt_key(keybuf
, 128, &s
->aes_decrypt_key
) != 0)
285 AES_encrypt(in
, tmp
, &s
->aes_encrypt_key
);
286 AES_decrypt(tmp
, out
, &s
->aes_decrypt_key
);
287 for(i
= 0; i
< 16; i
++)
288 printf(" %02x", tmp
[i
]);
290 for(i
= 0; i
< 16; i
++)
291 printf(" %02x", out
[i
]);
298 static int qcow_is_allocated(BlockDriverState
*bs
, int64_t sector_num
,
299 int nb_sectors
, int *pnum
)
301 uint64_t cluster_offset
;
304 cluster_offset
= qcow2_get_cluster_offset(bs
, sector_num
<< 9, pnum
);
306 return (cluster_offset
!= 0);
309 /* handle reading after the end of the backing file */
310 int qcow2_backing_read1(BlockDriverState
*bs
,
311 int64_t sector_num
, uint8_t *buf
, int nb_sectors
)
314 if ((sector_num
+ nb_sectors
) <= bs
->total_sectors
)
316 if (sector_num
>= bs
->total_sectors
)
319 n1
= bs
->total_sectors
- sector_num
;
320 memset(buf
+ n1
* 512, 0, 512 * (nb_sectors
- n1
));
324 typedef struct QCowAIOCB
{
325 BlockDriverAIOCB common
;
330 int remaining_sectors
;
331 int cur_nr_sectors
; /* number of sectors in current iteration */
332 uint64_t cluster_offset
;
333 uint8_t *cluster_data
;
334 BlockDriverAIOCB
*hd_aiocb
;
336 QEMUIOVector hd_qiov
;
339 QLIST_ENTRY(QCowAIOCB
) next_depend
;
342 static void qcow_aio_cancel(BlockDriverAIOCB
*blockacb
)
344 QCowAIOCB
*acb
= (QCowAIOCB
*)blockacb
;
346 bdrv_aio_cancel(acb
->hd_aiocb
);
347 qemu_aio_release(acb
);
350 static AIOPool qcow_aio_pool
= {
351 .aiocb_size
= sizeof(QCowAIOCB
),
352 .cancel
= qcow_aio_cancel
,
355 static void qcow_aio_read_cb(void *opaque
, int ret
);
356 static void qcow_aio_read_bh(void *opaque
)
358 QCowAIOCB
*acb
= opaque
;
359 qemu_bh_delete(acb
->bh
);
361 qcow_aio_read_cb(opaque
, 0);
364 static int qcow_schedule_bh(QEMUBHFunc
*cb
, QCowAIOCB
*acb
)
369 acb
->bh
= qemu_bh_new(cb
, acb
);
373 qemu_bh_schedule(acb
->bh
);
378 static void qcow_aio_read_cb(void *opaque
, int ret
)
380 QCowAIOCB
*acb
= opaque
;
381 BlockDriverState
*bs
= acb
->common
.bs
;
382 BDRVQcowState
*s
= bs
->opaque
;
383 int index_in_cluster
, n1
;
385 acb
->hd_aiocb
= NULL
;
389 /* post process the read buffer */
390 if (!acb
->cluster_offset
) {
392 } else if (acb
->cluster_offset
& QCOW_OFLAG_COMPRESSED
) {
395 if (s
->crypt_method
) {
396 qcow2_encrypt_sectors(s
, acb
->sector_num
, acb
->buf
, acb
->buf
,
397 acb
->cur_nr_sectors
, 0,
398 &s
->aes_decrypt_key
);
402 acb
->remaining_sectors
-= acb
->cur_nr_sectors
;
403 acb
->sector_num
+= acb
->cur_nr_sectors
;
404 acb
->buf
+= acb
->cur_nr_sectors
* 512;
406 if (acb
->remaining_sectors
== 0) {
407 /* request completed */
412 /* prepare next AIO request */
413 acb
->cur_nr_sectors
= acb
->remaining_sectors
;
414 acb
->cluster_offset
= qcow2_get_cluster_offset(bs
, acb
->sector_num
<< 9,
415 &acb
->cur_nr_sectors
);
416 index_in_cluster
= acb
->sector_num
& (s
->cluster_sectors
- 1);
418 if (!acb
->cluster_offset
) {
419 if (bs
->backing_hd
) {
420 /* read from the base image */
421 n1
= qcow2_backing_read1(bs
->backing_hd
, acb
->sector_num
,
422 acb
->buf
, acb
->cur_nr_sectors
);
424 acb
->hd_iov
.iov_base
= (void *)acb
->buf
;
425 acb
->hd_iov
.iov_len
= acb
->cur_nr_sectors
* 512;
426 qemu_iovec_init_external(&acb
->hd_qiov
, &acb
->hd_iov
, 1);
427 BLKDBG_EVENT(bs
->file
, BLKDBG_READ_BACKING_AIO
);
428 acb
->hd_aiocb
= bdrv_aio_readv(bs
->backing_hd
, acb
->sector_num
,
429 &acb
->hd_qiov
, acb
->cur_nr_sectors
,
430 qcow_aio_read_cb
, acb
);
431 if (acb
->hd_aiocb
== NULL
)
434 ret
= qcow_schedule_bh(qcow_aio_read_bh
, acb
);
439 /* Note: in this case, no need to wait */
440 memset(acb
->buf
, 0, 512 * acb
->cur_nr_sectors
);
441 ret
= qcow_schedule_bh(qcow_aio_read_bh
, acb
);
445 } else if (acb
->cluster_offset
& QCOW_OFLAG_COMPRESSED
) {
446 /* add AIO support for compressed blocks ? */
447 if (qcow2_decompress_cluster(bs
, acb
->cluster_offset
) < 0)
449 memcpy(acb
->buf
, s
->cluster_cache
+ index_in_cluster
* 512,
450 512 * acb
->cur_nr_sectors
);
451 ret
= qcow_schedule_bh(qcow_aio_read_bh
, acb
);
455 if ((acb
->cluster_offset
& 511) != 0) {
460 acb
->hd_iov
.iov_base
= (void *)acb
->buf
;
461 acb
->hd_iov
.iov_len
= acb
->cur_nr_sectors
* 512;
462 qemu_iovec_init_external(&acb
->hd_qiov
, &acb
->hd_iov
, 1);
463 BLKDBG_EVENT(bs
->file
, BLKDBG_READ_AIO
);
464 acb
->hd_aiocb
= bdrv_aio_readv(bs
->file
,
465 (acb
->cluster_offset
>> 9) + index_in_cluster
,
466 &acb
->hd_qiov
, acb
->cur_nr_sectors
,
467 qcow_aio_read_cb
, acb
);
468 if (acb
->hd_aiocb
== NULL
) {
476 if (acb
->qiov
->niov
> 1) {
477 qemu_iovec_from_buffer(acb
->qiov
, acb
->orig_buf
, acb
->qiov
->size
);
478 qemu_vfree(acb
->orig_buf
);
480 acb
->common
.cb(acb
->common
.opaque
, ret
);
481 qemu_aio_release(acb
);
484 static QCowAIOCB
*qcow_aio_setup(BlockDriverState
*bs
,
485 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
486 BlockDriverCompletionFunc
*cb
, void *opaque
, int is_write
)
490 acb
= qemu_aio_get(&qcow_aio_pool
, bs
, cb
, opaque
);
493 acb
->hd_aiocb
= NULL
;
494 acb
->sector_num
= sector_num
;
496 if (qiov
->niov
> 1) {
497 acb
->buf
= acb
->orig_buf
= qemu_blockalign(bs
, qiov
->size
);
499 qemu_iovec_to_buffer(qiov
, acb
->buf
);
501 acb
->buf
= (uint8_t *)qiov
->iov
->iov_base
;
503 acb
->remaining_sectors
= nb_sectors
;
504 acb
->cur_nr_sectors
= 0;
505 acb
->cluster_offset
= 0;
506 acb
->l2meta
.nb_clusters
= 0;
507 QLIST_INIT(&acb
->l2meta
.dependent_requests
);
511 static BlockDriverAIOCB
*qcow_aio_readv(BlockDriverState
*bs
,
512 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
513 BlockDriverCompletionFunc
*cb
, void *opaque
)
517 acb
= qcow_aio_setup(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 0);
521 qcow_aio_read_cb(acb
, 0);
525 static void qcow_aio_write_cb(void *opaque
, int ret
);
527 static void run_dependent_requests(QCowL2Meta
*m
)
532 /* Take the request off the list of running requests */
533 if (m
->nb_clusters
!= 0) {
534 QLIST_REMOVE(m
, next_in_flight
);
537 /* Restart all dependent requests */
538 QLIST_FOREACH_SAFE(req
, &m
->dependent_requests
, next_depend
, next
) {
539 qcow_aio_write_cb(req
, 0);
542 /* Empty the list for the next part of the request */
543 QLIST_INIT(&m
->dependent_requests
);
546 static void qcow_aio_write_cb(void *opaque
, int ret
)
548 QCowAIOCB
*acb
= opaque
;
549 BlockDriverState
*bs
= acb
->common
.bs
;
550 BDRVQcowState
*s
= bs
->opaque
;
551 int index_in_cluster
;
552 const uint8_t *src_buf
;
555 acb
->hd_aiocb
= NULL
;
558 ret
= qcow2_alloc_cluster_link_l2(bs
, &acb
->l2meta
);
561 run_dependent_requests(&acb
->l2meta
);
566 acb
->remaining_sectors
-= acb
->cur_nr_sectors
;
567 acb
->sector_num
+= acb
->cur_nr_sectors
;
568 acb
->buf
+= acb
->cur_nr_sectors
* 512;
570 if (acb
->remaining_sectors
== 0) {
571 /* request completed */
576 index_in_cluster
= acb
->sector_num
& (s
->cluster_sectors
- 1);
577 n_end
= index_in_cluster
+ acb
->remaining_sectors
;
578 if (s
->crypt_method
&&
579 n_end
> QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_sectors
)
580 n_end
= QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_sectors
;
582 ret
= qcow2_alloc_cluster_offset(bs
, acb
->sector_num
<< 9,
583 index_in_cluster
, n_end
, &acb
->cur_nr_sectors
, &acb
->l2meta
);
588 acb
->cluster_offset
= acb
->l2meta
.cluster_offset
;
590 /* Need to wait for another request? If so, we are done for now. */
591 if (acb
->l2meta
.nb_clusters
== 0 && acb
->l2meta
.depends_on
!= NULL
) {
592 QLIST_INSERT_HEAD(&acb
->l2meta
.depends_on
->dependent_requests
,
597 assert((acb
->cluster_offset
& 511) == 0);
599 if (s
->crypt_method
) {
600 if (!acb
->cluster_data
) {
601 acb
->cluster_data
= qemu_mallocz(QCOW_MAX_CRYPT_CLUSTERS
*
604 qcow2_encrypt_sectors(s
, acb
->sector_num
, acb
->cluster_data
, acb
->buf
,
605 acb
->cur_nr_sectors
, 1, &s
->aes_encrypt_key
);
606 src_buf
= acb
->cluster_data
;
610 acb
->hd_iov
.iov_base
= (void *)src_buf
;
611 acb
->hd_iov
.iov_len
= acb
->cur_nr_sectors
* 512;
612 qemu_iovec_init_external(&acb
->hd_qiov
, &acb
->hd_iov
, 1);
613 BLKDBG_EVENT(bs
->file
, BLKDBG_WRITE_AIO
);
614 acb
->hd_aiocb
= bdrv_aio_writev(bs
->file
,
615 (acb
->cluster_offset
>> 9) + index_in_cluster
,
616 &acb
->hd_qiov
, acb
->cur_nr_sectors
,
617 qcow_aio_write_cb
, acb
);
618 if (acb
->hd_aiocb
== NULL
) {
626 if (acb
->l2meta
.nb_clusters
!= 0) {
627 QLIST_REMOVE(&acb
->l2meta
, next_in_flight
);
630 if (acb
->qiov
->niov
> 1)
631 qemu_vfree(acb
->orig_buf
);
632 acb
->common
.cb(acb
->common
.opaque
, ret
);
633 qemu_aio_release(acb
);
636 static BlockDriverAIOCB
*qcow_aio_writev(BlockDriverState
*bs
,
637 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
638 BlockDriverCompletionFunc
*cb
, void *opaque
)
640 BDRVQcowState
*s
= bs
->opaque
;
643 s
->cluster_cache_offset
= -1; /* disable compressed cache */
645 acb
= qcow_aio_setup(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 1);
649 qcow_aio_write_cb(acb
, 0);
653 static void qcow_close(BlockDriverState
*bs
)
655 BDRVQcowState
*s
= bs
->opaque
;
656 qemu_free(s
->l1_table
);
657 qemu_free(s
->l2_cache
);
658 qemu_free(s
->cluster_cache
);
659 qemu_free(s
->cluster_data
);
660 qcow2_refcount_close(bs
);
664 * Updates the variable length parts of the qcow2 header, i.e. the backing file
665 * name and all extensions. qcow2 was not designed to allow such changes, so if
666 * we run out of space (we can only use the first cluster) this function may
669 * Returns 0 on success, -errno in error cases.
671 static int qcow2_update_ext_header(BlockDriverState
*bs
,
672 const char *backing_file
, const char *backing_fmt
)
674 size_t backing_file_len
= 0;
675 size_t backing_fmt_len
= 0;
676 BDRVQcowState
*s
= bs
->opaque
;
677 QCowExtension ext_backing_fmt
= {0, 0};
680 /* Backing file format doesn't make sense without a backing file */
681 if (backing_fmt
&& !backing_file
) {
685 /* Prepare the backing file format extension if needed */
687 ext_backing_fmt
.len
= cpu_to_be32(strlen(backing_fmt
));
688 ext_backing_fmt
.magic
= cpu_to_be32(QCOW_EXT_MAGIC_BACKING_FORMAT
);
689 backing_fmt_len
= ((sizeof(ext_backing_fmt
)
690 + strlen(backing_fmt
) + 7) & ~7);
693 /* Check if we can fit the new header into the first cluster */
695 backing_file_len
= strlen(backing_file
);
698 size_t header_size
= sizeof(QCowHeader
) + backing_file_len
701 if (header_size
> s
->cluster_size
) {
705 /* Rewrite backing file name and qcow2 extensions */
706 size_t ext_size
= header_size
- sizeof(QCowHeader
);
707 uint8_t buf
[ext_size
];
709 size_t backing_file_offset
= 0;
713 int padding
= backing_fmt_len
-
714 (sizeof(ext_backing_fmt
) + strlen(backing_fmt
));
716 memcpy(buf
+ offset
, &ext_backing_fmt
, sizeof(ext_backing_fmt
));
717 offset
+= sizeof(ext_backing_fmt
);
719 memcpy(buf
+ offset
, backing_fmt
, strlen(backing_fmt
));
720 offset
+= strlen(backing_fmt
);
722 memset(buf
+ offset
, 0, padding
);
726 memcpy(buf
+ offset
, backing_file
, backing_file_len
);
727 backing_file_offset
= sizeof(QCowHeader
) + offset
;
730 ret
= bdrv_pwrite(bs
->file
, sizeof(QCowHeader
), buf
, ext_size
);
735 /* Update header fields */
736 uint64_t be_backing_file_offset
= cpu_to_be64(backing_file_offset
);
737 uint32_t be_backing_file_size
= cpu_to_be32(backing_file_len
);
739 ret
= bdrv_pwrite(bs
->file
, offsetof(QCowHeader
, backing_file_offset
),
740 &be_backing_file_offset
, sizeof(uint64_t));
745 ret
= bdrv_pwrite(bs
->file
, offsetof(QCowHeader
, backing_file_size
),
746 &be_backing_file_size
, sizeof(uint32_t));
756 static int qcow2_change_backing_file(BlockDriverState
*bs
,
757 const char *backing_file
, const char *backing_fmt
)
759 return qcow2_update_ext_header(bs
, backing_file
, backing_fmt
);
762 static int get_bits_from_size(size_t size
)
771 /* Not a power of two */
784 static int preallocate(BlockDriverState
*bs
)
792 nb_sectors
= bdrv_getlength(bs
) >> 9;
794 QLIST_INIT(&meta
.dependent_requests
);
795 meta
.cluster_offset
= 0;
798 num
= MIN(nb_sectors
, INT_MAX
>> 9);
799 ret
= qcow2_alloc_cluster_offset(bs
, offset
, 0, num
, &num
, &meta
);
805 if (qcow2_alloc_cluster_link_l2(bs
, &meta
) < 0) {
806 qcow2_free_any_clusters(bs
, meta
.cluster_offset
, meta
.nb_clusters
);
810 /* There are no dependent requests, but we need to remove our request
811 * from the list of in-flight requests */
812 run_dependent_requests(&meta
);
814 /* TODO Preallocate data if requested */
821 * It is expected that the image file is large enough to actually contain
822 * all of the allocated clusters (otherwise we get failing reads after
823 * EOF). Extend the image to the last allocated sector.
825 if (meta
.cluster_offset
!= 0) {
828 bdrv_write(bs
->file
, (meta
.cluster_offset
>> 9) + num
- 1, buf
, 1);
834 static int qcow_make_empty(BlockDriverState
*bs
)
837 /* XXX: not correct */
838 BDRVQcowState
*s
= bs
->opaque
;
839 uint32_t l1_length
= s
->l1_size
* sizeof(uint64_t);
842 memset(s
->l1_table
, 0, l1_length
);
843 if (bdrv_pwrite(bs
->file
, s
->l1_table_offset
, s
->l1_table
, l1_length
) < 0)
845 ret
= bdrv_truncate(bs
->file
, s
->l1_table_offset
+ l1_length
);
854 /* XXX: put compressed sectors first, then all the cluster aligned
855 tables to avoid losing bytes in alignment */
856 static int qcow_write_compressed(BlockDriverState
*bs
, int64_t sector_num
,
857 const uint8_t *buf
, int nb_sectors
)
859 BDRVQcowState
*s
= bs
->opaque
;
863 uint64_t cluster_offset
;
865 if (nb_sectors
== 0) {
866 /* align end of file to a sector boundary to ease reading with
868 cluster_offset
= bdrv_getlength(bs
->file
);
869 cluster_offset
= (cluster_offset
+ 511) & ~511;
870 bdrv_truncate(bs
->file
, cluster_offset
);
874 if (nb_sectors
!= s
->cluster_sectors
)
877 out_buf
= qemu_malloc(s
->cluster_size
+ (s
->cluster_size
/ 1000) + 128);
879 /* best compression, small window, no zlib header */
880 memset(&strm
, 0, sizeof(strm
));
881 ret
= deflateInit2(&strm
, Z_DEFAULT_COMPRESSION
,
883 9, Z_DEFAULT_STRATEGY
);
889 strm
.avail_in
= s
->cluster_size
;
890 strm
.next_in
= (uint8_t *)buf
;
891 strm
.avail_out
= s
->cluster_size
;
892 strm
.next_out
= out_buf
;
894 ret
= deflate(&strm
, Z_FINISH
);
895 if (ret
!= Z_STREAM_END
&& ret
!= Z_OK
) {
900 out_len
= strm
.next_out
- out_buf
;
904 if (ret
!= Z_STREAM_END
|| out_len
>= s
->cluster_size
) {
905 /* could not compress: write normal cluster */
906 bdrv_write(bs
, sector_num
, buf
, s
->cluster_sectors
);
908 cluster_offset
= qcow2_alloc_compressed_cluster_offset(bs
,
909 sector_num
<< 9, out_len
);
912 cluster_offset
&= s
->cluster_offset_mask
;
913 BLKDBG_EVENT(bs
->file
, BLKDBG_WRITE_COMPRESSED
);
914 if (bdrv_pwrite(bs
->file
, cluster_offset
, out_buf
, out_len
) != out_len
) {
924 static void qcow_flush(BlockDriverState
*bs
)
926 bdrv_flush(bs
->file
);
929 static BlockDriverAIOCB
*qcow_aio_flush(BlockDriverState
*bs
,
930 BlockDriverCompletionFunc
*cb
, void *opaque
)
932 return bdrv_aio_flush(bs
->file
, cb
, opaque
);
935 static int64_t qcow_vm_state_offset(BDRVQcowState
*s
)
937 return (int64_t)s
->l1_vm_state_index
<< (s
->cluster_bits
+ s
->l2_bits
);
940 static int qcow_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
942 BDRVQcowState
*s
= bs
->opaque
;
943 bdi
->cluster_size
= s
->cluster_size
;
944 bdi
->vm_state_offset
= qcow_vm_state_offset(s
);
949 static int qcow_check(BlockDriverState
*bs
)
951 return qcow2_check_refcounts(bs
);
955 static void dump_refcounts(BlockDriverState
*bs
)
957 BDRVQcowState
*s
= bs
->opaque
;
958 int64_t nb_clusters
, k
, k1
, size
;
961 size
= bdrv_getlength(bs
->file
);
962 nb_clusters
= size_to_clusters(s
, size
);
963 for(k
= 0; k
< nb_clusters
;) {
965 refcount
= get_refcount(bs
, k
);
967 while (k
< nb_clusters
&& get_refcount(bs
, k
) == refcount
)
969 printf("%lld: refcount=%d nb=%lld\n", k
, refcount
, k
- k1
);
974 static int qcow_save_vmstate(BlockDriverState
*bs
, const uint8_t *buf
,
975 int64_t pos
, int size
)
977 BDRVQcowState
*s
= bs
->opaque
;
978 int growable
= bs
->growable
;
981 BLKDBG_EVENT(bs
->file
, BLKDBG_VMSTATE_SAVE
);
983 ret
= bdrv_pwrite(bs
, qcow_vm_state_offset(s
) + pos
, buf
, size
);
984 bs
->growable
= growable
;
989 static int qcow_load_vmstate(BlockDriverState
*bs
, uint8_t *buf
,
990 int64_t pos
, int size
)
992 BDRVQcowState
*s
= bs
->opaque
;
993 int growable
= bs
->growable
;
996 BLKDBG_EVENT(bs
->file
, BLKDBG_VMSTATE_LOAD
);
998 ret
= bdrv_pread(bs
, qcow_vm_state_offset(s
) + pos
, buf
, size
);
999 bs
->growable
= growable
;
1004 static QEMUOptionParameter qcow_create_options
[] = {
1006 .name
= BLOCK_OPT_SIZE
,
1008 .help
= "Virtual disk size"
1011 .name
= BLOCK_OPT_BACKING_FILE
,
1013 .help
= "File name of a base image"
1016 .name
= BLOCK_OPT_BACKING_FMT
,
1018 .help
= "Image format of the base image"
1021 .name
= BLOCK_OPT_ENCRYPT
,
1023 .help
= "Encrypt the image"
1026 .name
= BLOCK_OPT_CLUSTER_SIZE
,
1028 .help
= "qcow2 cluster size"
1031 .name
= BLOCK_OPT_PREALLOC
,
1033 .help
= "Preallocation mode (allowed values: off, metadata)"
1038 static BlockDriver bdrv_qcow2
= {
1039 .format_name
= "qcow2",
1040 .instance_size
= sizeof(BDRVQcowState
),
1041 .bdrv_probe
= qcow_probe
,
1042 .bdrv_open
= qcow_open
,
1043 .bdrv_close
= qcow_close
,
1044 .bdrv_create
= qcow_create
,
1045 .bdrv_flush
= qcow_flush
,
1046 .bdrv_is_allocated
= qcow_is_allocated
,
1047 .bdrv_set_key
= qcow_set_key
,
1048 .bdrv_make_empty
= qcow_make_empty
,
1050 .bdrv_aio_readv
= qcow_aio_readv
,
1051 .bdrv_aio_writev
= qcow_aio_writev
,
1052 .bdrv_aio_flush
= qcow_aio_flush
,
1053 .bdrv_write_compressed
= qcow_write_compressed
,
1055 .bdrv_snapshot_create
= qcow2_snapshot_create
,
1056 .bdrv_snapshot_goto
= qcow2_snapshot_goto
,
1057 .bdrv_snapshot_delete
= qcow2_snapshot_delete
,
1058 .bdrv_snapshot_list
= qcow2_snapshot_list
,
1059 .bdrv_get_info
= qcow_get_info
,
1061 .bdrv_save_vmstate
= qcow_save_vmstate
,
1062 .bdrv_load_vmstate
= qcow_load_vmstate
,
1064 .bdrv_change_backing_file
= qcow2_change_backing_file
,
1066 .create_options
= qcow_create_options
,
1067 .bdrv_check
= qcow_check
,
1070 static int qcow_create2(const char *filename
, int64_t total_size
,
1071 const char *backing_file
, const char *backing_format
,
1072 int flags
, size_t cluster_size
, int prealloc
)
1075 int fd
, header_size
, backing_filename_len
, l1_size
, i
, shift
, l2_bits
;
1076 int ref_clusters
, reftable_clusters
, backing_format_len
= 0;
1077 int rounded_ext_bf_len
= 0;
1079 uint64_t tmp
, offset
;
1080 uint64_t old_ref_clusters
;
1081 QCowCreateState s1
, *s
= &s1
;
1082 QCowExtension ext_bf
= {0, 0};
1085 memset(s
, 0, sizeof(*s
));
1087 fd
= open(filename
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_BINARY
, 0644);
1090 memset(&header
, 0, sizeof(header
));
1091 header
.magic
= cpu_to_be32(QCOW_MAGIC
);
1092 header
.version
= cpu_to_be32(QCOW_VERSION
);
1093 header
.size
= cpu_to_be64(total_size
* 512);
1094 header_size
= sizeof(header
);
1095 backing_filename_len
= 0;
1097 if (backing_format
) {
1098 ext_bf
.magic
= QCOW_EXT_MAGIC_BACKING_FORMAT
;
1099 backing_format_len
= strlen(backing_format
);
1100 ext_bf
.len
= backing_format_len
;
1101 rounded_ext_bf_len
= (sizeof(ext_bf
) + ext_bf
.len
+ 7) & ~7;
1102 header_size
+= rounded_ext_bf_len
;
1104 header
.backing_file_offset
= cpu_to_be64(header_size
);
1105 backing_filename_len
= strlen(backing_file
);
1106 header
.backing_file_size
= cpu_to_be32(backing_filename_len
);
1107 header_size
+= backing_filename_len
;
1111 s
->cluster_bits
= get_bits_from_size(cluster_size
);
1112 if (s
->cluster_bits
< MIN_CLUSTER_BITS
||
1113 s
->cluster_bits
> MAX_CLUSTER_BITS
)
1115 fprintf(stderr
, "Cluster size must be a power of two between "
1117 1 << MIN_CLUSTER_BITS
,
1118 1 << (MAX_CLUSTER_BITS
- 10));
1121 s
->cluster_size
= 1 << s
->cluster_bits
;
1123 header
.cluster_bits
= cpu_to_be32(s
->cluster_bits
);
1124 header_size
= (header_size
+ 7) & ~7;
1125 if (flags
& BLOCK_FLAG_ENCRYPT
) {
1126 header
.crypt_method
= cpu_to_be32(QCOW_CRYPT_AES
);
1128 header
.crypt_method
= cpu_to_be32(QCOW_CRYPT_NONE
);
1130 l2_bits
= s
->cluster_bits
- 3;
1131 shift
= s
->cluster_bits
+ l2_bits
;
1132 l1_size
= (((total_size
* 512) + (1LL << shift
) - 1) >> shift
);
1133 offset
= align_offset(header_size
, s
->cluster_size
);
1134 s
->l1_table_offset
= offset
;
1135 header
.l1_table_offset
= cpu_to_be64(s
->l1_table_offset
);
1136 header
.l1_size
= cpu_to_be32(l1_size
);
1137 offset
+= align_offset(l1_size
* sizeof(uint64_t), s
->cluster_size
);
1139 /* count how many refcount blocks needed */
1141 #define NUM_CLUSTERS(bytes) \
1142 (((bytes) + (s->cluster_size) - 1) / (s->cluster_size))
1144 ref_clusters
= NUM_CLUSTERS(NUM_CLUSTERS(offset
) * sizeof(uint16_t));
1147 uint64_t image_clusters
;
1148 old_ref_clusters
= ref_clusters
;
1150 /* Number of clusters used for the refcount table */
1151 reftable_clusters
= NUM_CLUSTERS(ref_clusters
* sizeof(uint64_t));
1153 /* Number of clusters that the whole image will have */
1154 image_clusters
= NUM_CLUSTERS(offset
) + ref_clusters
1155 + reftable_clusters
;
1157 /* Number of refcount blocks needed for the image */
1158 ref_clusters
= NUM_CLUSTERS(image_clusters
* sizeof(uint16_t));
1160 } while (ref_clusters
!= old_ref_clusters
);
1162 s
->refcount_table
= qemu_mallocz(reftable_clusters
* s
->cluster_size
);
1164 s
->refcount_table_offset
= offset
;
1165 header
.refcount_table_offset
= cpu_to_be64(offset
);
1166 header
.refcount_table_clusters
= cpu_to_be32(reftable_clusters
);
1167 offset
+= (reftable_clusters
* s
->cluster_size
);
1168 s
->refcount_block_offset
= offset
;
1170 for (i
=0; i
< ref_clusters
; i
++) {
1171 s
->refcount_table
[i
] = cpu_to_be64(offset
);
1172 offset
+= s
->cluster_size
;
1175 s
->refcount_block
= qemu_mallocz(ref_clusters
* s
->cluster_size
);
1177 /* update refcounts */
1178 qcow2_create_refcount_update(s
, 0, header_size
);
1179 qcow2_create_refcount_update(s
, s
->l1_table_offset
,
1180 l1_size
* sizeof(uint64_t));
1181 qcow2_create_refcount_update(s
, s
->refcount_table_offset
,
1182 reftable_clusters
* s
->cluster_size
);
1183 qcow2_create_refcount_update(s
, s
->refcount_block_offset
,
1184 ref_clusters
* s
->cluster_size
);
1186 /* write all the data */
1187 ret
= qemu_write_full(fd
, &header
, sizeof(header
));
1188 if (ret
!= sizeof(header
)) {
1193 if (backing_format_len
) {
1195 int padding
= rounded_ext_bf_len
- (ext_bf
.len
+ sizeof(ext_bf
));
1197 memset(zero
, 0, sizeof(zero
));
1198 cpu_to_be32s(&ext_bf
.magic
);
1199 cpu_to_be32s(&ext_bf
.len
);
1200 ret
= qemu_write_full(fd
, &ext_bf
, sizeof(ext_bf
));
1201 if (ret
!= sizeof(ext_bf
)) {
1205 ret
= qemu_write_full(fd
, backing_format
, backing_format_len
);
1206 if (ret
!= backing_format_len
) {
1211 ret
= qemu_write_full(fd
, zero
, padding
);
1212 if (ret
!= padding
) {
1218 ret
= qemu_write_full(fd
, backing_file
, backing_filename_len
);
1219 if (ret
!= backing_filename_len
) {
1224 lseek(fd
, s
->l1_table_offset
, SEEK_SET
);
1226 for(i
= 0;i
< l1_size
; i
++) {
1227 ret
= qemu_write_full(fd
, &tmp
, sizeof(tmp
));
1228 if (ret
!= sizeof(tmp
)) {
1233 lseek(fd
, s
->refcount_table_offset
, SEEK_SET
);
1234 ret
= qemu_write_full(fd
, s
->refcount_table
,
1235 reftable_clusters
* s
->cluster_size
);
1236 if (ret
!= reftable_clusters
* s
->cluster_size
) {
1241 lseek(fd
, s
->refcount_block_offset
, SEEK_SET
);
1242 ret
= qemu_write_full(fd
, s
->refcount_block
,
1243 ref_clusters
* s
->cluster_size
);
1244 if (ret
!= ref_clusters
* s
->cluster_size
) {
1251 qemu_free(s
->refcount_table
);
1252 qemu_free(s
->refcount_block
);
1255 /* Preallocate metadata */
1256 if (ret
== 0 && prealloc
) {
1257 BlockDriverState
*bs
;
1259 bdrv_open(bs
, filename
, BDRV_O_CACHE_WB
| BDRV_O_RDWR
, &bdrv_qcow2
);
1267 static int qcow_create(const char *filename
, QEMUOptionParameter
*options
)
1269 const char *backing_file
= NULL
;
1270 const char *backing_fmt
= NULL
;
1271 uint64_t sectors
= 0;
1273 size_t cluster_size
= 65536;
1276 /* Read out options */
1277 while (options
&& options
->name
) {
1278 if (!strcmp(options
->name
, BLOCK_OPT_SIZE
)) {
1279 sectors
= options
->value
.n
/ 512;
1280 } else if (!strcmp(options
->name
, BLOCK_OPT_BACKING_FILE
)) {
1281 backing_file
= options
->value
.s
;
1282 } else if (!strcmp(options
->name
, BLOCK_OPT_BACKING_FMT
)) {
1283 backing_fmt
= options
->value
.s
;
1284 } else if (!strcmp(options
->name
, BLOCK_OPT_ENCRYPT
)) {
1285 flags
|= options
->value
.n
? BLOCK_FLAG_ENCRYPT
: 0;
1286 } else if (!strcmp(options
->name
, BLOCK_OPT_CLUSTER_SIZE
)) {
1287 if (options
->value
.n
) {
1288 cluster_size
= options
->value
.n
;
1290 } else if (!strcmp(options
->name
, BLOCK_OPT_PREALLOC
)) {
1291 if (!options
->value
.s
|| !strcmp(options
->value
.s
, "off")) {
1293 } else if (!strcmp(options
->value
.s
, "metadata")) {
1296 fprintf(stderr
, "Invalid preallocation mode: '%s'\n",
1304 if (backing_file
&& prealloc
) {
1305 fprintf(stderr
, "Backing file and preallocation cannot be used at "
1310 return qcow_create2(filename
, sectors
, backing_file
, backing_fmt
, flags
,
1311 cluster_size
, prealloc
);
1314 static void bdrv_qcow2_init(void)
1316 bdrv_register(&bdrv_qcow2
);
1319 block_init(bdrv_qcow2_init
);