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_probe(const uint8_t *buf
, int buf_size
, const char *filename
)
57 const QCowHeader
*cow_header
= (const void *)buf
;
59 if (buf_size
>= sizeof(QCowHeader
) &&
60 be32_to_cpu(cow_header
->magic
) == QCOW_MAGIC
&&
61 be32_to_cpu(cow_header
->version
) == QCOW_VERSION
)
69 * read qcow2 extension and fill bs
70 * start reading from start_offset
71 * finish reading upon magic of value 0 or when end_offset reached
72 * unknown magic is skipped (future extension this version knows nothing about)
73 * return 0 upon success, non-0 otherwise
75 static int qcow_read_extensions(BlockDriverState
*bs
, uint64_t start_offset
,
82 printf("qcow_read_extensions: start=%ld end=%ld\n", start_offset
, end_offset
);
84 offset
= start_offset
;
85 while (offset
< end_offset
) {
89 if (offset
> s
->cluster_size
)
90 printf("qcow_handle_extension: suspicious offset %lu\n", offset
);
92 printf("attemting to read extended header in offset %lu\n", offset
);
95 if (bdrv_pread(bs
->file
, offset
, &ext
, sizeof(ext
)) != sizeof(ext
)) {
96 fprintf(stderr
, "qcow_handle_extension: ERROR: "
97 "pread fail from offset %" PRIu64
"\n",
101 be32_to_cpus(&ext
.magic
);
102 be32_to_cpus(&ext
.len
);
103 offset
+= sizeof(ext
);
105 printf("ext.magic = 0x%x\n", ext
.magic
);
108 case QCOW_EXT_MAGIC_END
:
111 case QCOW_EXT_MAGIC_BACKING_FORMAT
:
112 if (ext
.len
>= sizeof(bs
->backing_format
)) {
113 fprintf(stderr
, "ERROR: ext_backing_format: len=%u too large"
115 ext
.len
, sizeof(bs
->backing_format
));
118 if (bdrv_pread(bs
->file
, offset
, bs
->backing_format
,
121 bs
->backing_format
[ext
.len
] = '\0';
123 printf("Qcow2: Got format extension %s\n", bs
->backing_format
);
125 offset
= ((offset
+ ext
.len
+ 7) & ~7);
129 /* unknown magic -- just skip it */
130 offset
= ((offset
+ ext
.len
+ 7) & ~7);
139 static int qcow_open(BlockDriverState
*bs
, int flags
)
141 BDRVQcowState
*s
= bs
->opaque
;
146 if (bdrv_pread(bs
->file
, 0, &header
, sizeof(header
)) != sizeof(header
))
148 be32_to_cpus(&header
.magic
);
149 be32_to_cpus(&header
.version
);
150 be64_to_cpus(&header
.backing_file_offset
);
151 be32_to_cpus(&header
.backing_file_size
);
152 be64_to_cpus(&header
.size
);
153 be32_to_cpus(&header
.cluster_bits
);
154 be32_to_cpus(&header
.crypt_method
);
155 be64_to_cpus(&header
.l1_table_offset
);
156 be32_to_cpus(&header
.l1_size
);
157 be64_to_cpus(&header
.refcount_table_offset
);
158 be32_to_cpus(&header
.refcount_table_clusters
);
159 be64_to_cpus(&header
.snapshots_offset
);
160 be32_to_cpus(&header
.nb_snapshots
);
162 if (header
.magic
!= QCOW_MAGIC
|| header
.version
!= QCOW_VERSION
)
164 if (header
.cluster_bits
< MIN_CLUSTER_BITS
||
165 header
.cluster_bits
> MAX_CLUSTER_BITS
)
167 if (header
.crypt_method
> QCOW_CRYPT_AES
)
169 s
->crypt_method_header
= header
.crypt_method
;
170 if (s
->crypt_method_header
)
172 s
->cluster_bits
= header
.cluster_bits
;
173 s
->cluster_size
= 1 << s
->cluster_bits
;
174 s
->cluster_sectors
= 1 << (s
->cluster_bits
- 9);
175 s
->l2_bits
= s
->cluster_bits
- 3; /* L2 is always one cluster */
176 s
->l2_size
= 1 << s
->l2_bits
;
177 bs
->total_sectors
= header
.size
/ 512;
178 s
->csize_shift
= (62 - (s
->cluster_bits
- 8));
179 s
->csize_mask
= (1 << (s
->cluster_bits
- 8)) - 1;
180 s
->cluster_offset_mask
= (1LL << s
->csize_shift
) - 1;
181 s
->refcount_table_offset
= header
.refcount_table_offset
;
182 s
->refcount_table_size
=
183 header
.refcount_table_clusters
<< (s
->cluster_bits
- 3);
185 s
->snapshots_offset
= header
.snapshots_offset
;
186 s
->nb_snapshots
= header
.nb_snapshots
;
188 /* read the level 1 table */
189 s
->l1_size
= header
.l1_size
;
190 s
->l1_vm_state_index
= size_to_l1(s
, header
.size
);
191 /* the L1 table must contain at least enough entries to put
193 if (s
->l1_size
< s
->l1_vm_state_index
)
195 s
->l1_table_offset
= header
.l1_table_offset
;
196 if (s
->l1_size
> 0) {
197 s
->l1_table
= qemu_mallocz(
198 align_offset(s
->l1_size
* sizeof(uint64_t), 512));
199 if (bdrv_pread(bs
->file
, s
->l1_table_offset
, s
->l1_table
, s
->l1_size
* sizeof(uint64_t)) !=
200 s
->l1_size
* sizeof(uint64_t))
202 for(i
= 0;i
< s
->l1_size
; i
++) {
203 be64_to_cpus(&s
->l1_table
[i
]);
207 s
->l2_cache
= qemu_malloc(s
->l2_size
* L2_CACHE_SIZE
* sizeof(uint64_t));
208 s
->cluster_cache
= qemu_malloc(s
->cluster_size
);
209 /* one more sector for decompressed data alignment */
210 s
->cluster_data
= qemu_malloc(QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
212 s
->cluster_cache_offset
= -1;
214 if (qcow2_refcount_init(bs
) < 0)
217 QLIST_INIT(&s
->cluster_allocs
);
219 /* read qcow2 extensions */
220 if (header
.backing_file_offset
)
221 ext_end
= header
.backing_file_offset
;
223 ext_end
= s
->cluster_size
;
224 if (qcow_read_extensions(bs
, sizeof(header
), ext_end
))
227 /* read the backing file name */
228 if (header
.backing_file_offset
!= 0) {
229 len
= header
.backing_file_size
;
232 if (bdrv_pread(bs
->file
, header
.backing_file_offset
, bs
->backing_file
, len
) != len
)
234 bs
->backing_file
[len
] = '\0';
236 if (qcow2_read_snapshots(bs
) < 0)
240 qcow2_check_refcounts(bs
);
245 qcow2_free_snapshots(bs
);
246 qcow2_refcount_close(bs
);
247 qemu_free(s
->l1_table
);
248 qemu_free(s
->l2_cache
);
249 qemu_free(s
->cluster_cache
);
250 qemu_free(s
->cluster_data
);
254 static int qcow_set_key(BlockDriverState
*bs
, const char *key
)
256 BDRVQcowState
*s
= bs
->opaque
;
260 memset(keybuf
, 0, 16);
264 /* XXX: we could compress the chars to 7 bits to increase
266 for(i
= 0;i
< len
;i
++) {
269 s
->crypt_method
= s
->crypt_method_header
;
271 if (AES_set_encrypt_key(keybuf
, 128, &s
->aes_encrypt_key
) != 0)
273 if (AES_set_decrypt_key(keybuf
, 128, &s
->aes_decrypt_key
) != 0)
283 AES_encrypt(in
, tmp
, &s
->aes_encrypt_key
);
284 AES_decrypt(tmp
, out
, &s
->aes_decrypt_key
);
285 for(i
= 0; i
< 16; i
++)
286 printf(" %02x", tmp
[i
]);
288 for(i
= 0; i
< 16; i
++)
289 printf(" %02x", out
[i
]);
296 static int qcow_is_allocated(BlockDriverState
*bs
, int64_t sector_num
,
297 int nb_sectors
, int *pnum
)
299 uint64_t cluster_offset
;
302 cluster_offset
= qcow2_get_cluster_offset(bs
, sector_num
<< 9, pnum
);
304 return (cluster_offset
!= 0);
307 /* handle reading after the end of the backing file */
308 int qcow2_backing_read1(BlockDriverState
*bs
,
309 int64_t sector_num
, uint8_t *buf
, int nb_sectors
)
312 if ((sector_num
+ nb_sectors
) <= bs
->total_sectors
)
314 if (sector_num
>= bs
->total_sectors
)
317 n1
= bs
->total_sectors
- sector_num
;
318 memset(buf
+ n1
* 512, 0, 512 * (nb_sectors
- n1
));
322 typedef struct QCowAIOCB
{
323 BlockDriverAIOCB common
;
328 int remaining_sectors
;
329 int cur_nr_sectors
; /* number of sectors in current iteration */
330 uint64_t cluster_offset
;
331 uint8_t *cluster_data
;
332 BlockDriverAIOCB
*hd_aiocb
;
334 QEMUIOVector hd_qiov
;
337 QLIST_ENTRY(QCowAIOCB
) next_depend
;
340 static void qcow_aio_cancel(BlockDriverAIOCB
*blockacb
)
342 QCowAIOCB
*acb
= container_of(blockacb
, QCowAIOCB
, common
);
344 bdrv_aio_cancel(acb
->hd_aiocb
);
345 qemu_aio_release(acb
);
348 static AIOPool qcow_aio_pool
= {
349 .aiocb_size
= sizeof(QCowAIOCB
),
350 .cancel
= qcow_aio_cancel
,
353 static void qcow_aio_read_cb(void *opaque
, int ret
);
354 static void qcow_aio_read_bh(void *opaque
)
356 QCowAIOCB
*acb
= opaque
;
357 qemu_bh_delete(acb
->bh
);
359 qcow_aio_read_cb(opaque
, 0);
362 static int qcow_schedule_bh(QEMUBHFunc
*cb
, QCowAIOCB
*acb
)
367 acb
->bh
= qemu_bh_new(cb
, acb
);
371 qemu_bh_schedule(acb
->bh
);
376 static void qcow_aio_read_cb(void *opaque
, int ret
)
378 QCowAIOCB
*acb
= opaque
;
379 BlockDriverState
*bs
= acb
->common
.bs
;
380 BDRVQcowState
*s
= bs
->opaque
;
381 int index_in_cluster
, n1
;
383 acb
->hd_aiocb
= NULL
;
387 /* post process the read buffer */
388 if (!acb
->cluster_offset
) {
390 } else if (acb
->cluster_offset
& QCOW_OFLAG_COMPRESSED
) {
393 if (s
->crypt_method
) {
394 qcow2_encrypt_sectors(s
, acb
->sector_num
, acb
->buf
, acb
->buf
,
395 acb
->cur_nr_sectors
, 0,
396 &s
->aes_decrypt_key
);
400 acb
->remaining_sectors
-= acb
->cur_nr_sectors
;
401 acb
->sector_num
+= acb
->cur_nr_sectors
;
402 acb
->buf
+= acb
->cur_nr_sectors
* 512;
404 if (acb
->remaining_sectors
== 0) {
405 /* request completed */
410 /* prepare next AIO request */
411 acb
->cur_nr_sectors
= acb
->remaining_sectors
;
412 acb
->cluster_offset
= qcow2_get_cluster_offset(bs
, acb
->sector_num
<< 9,
413 &acb
->cur_nr_sectors
);
414 index_in_cluster
= acb
->sector_num
& (s
->cluster_sectors
- 1);
416 if (!acb
->cluster_offset
) {
417 if (bs
->backing_hd
) {
418 /* read from the base image */
419 n1
= qcow2_backing_read1(bs
->backing_hd
, acb
->sector_num
,
420 acb
->buf
, acb
->cur_nr_sectors
);
422 acb
->hd_iov
.iov_base
= (void *)acb
->buf
;
423 acb
->hd_iov
.iov_len
= acb
->cur_nr_sectors
* 512;
424 qemu_iovec_init_external(&acb
->hd_qiov
, &acb
->hd_iov
, 1);
425 BLKDBG_EVENT(bs
->file
, BLKDBG_READ_BACKING_AIO
);
426 acb
->hd_aiocb
= bdrv_aio_readv(bs
->backing_hd
, acb
->sector_num
,
427 &acb
->hd_qiov
, acb
->cur_nr_sectors
,
428 qcow_aio_read_cb
, acb
);
429 if (acb
->hd_aiocb
== NULL
)
432 ret
= qcow_schedule_bh(qcow_aio_read_bh
, acb
);
437 /* Note: in this case, no need to wait */
438 memset(acb
->buf
, 0, 512 * acb
->cur_nr_sectors
);
439 ret
= qcow_schedule_bh(qcow_aio_read_bh
, acb
);
443 } else if (acb
->cluster_offset
& QCOW_OFLAG_COMPRESSED
) {
444 /* add AIO support for compressed blocks ? */
445 if (qcow2_decompress_cluster(bs
, acb
->cluster_offset
) < 0)
447 memcpy(acb
->buf
, s
->cluster_cache
+ index_in_cluster
* 512,
448 512 * acb
->cur_nr_sectors
);
449 ret
= qcow_schedule_bh(qcow_aio_read_bh
, acb
);
453 if ((acb
->cluster_offset
& 511) != 0) {
458 acb
->hd_iov
.iov_base
= (void *)acb
->buf
;
459 acb
->hd_iov
.iov_len
= acb
->cur_nr_sectors
* 512;
460 qemu_iovec_init_external(&acb
->hd_qiov
, &acb
->hd_iov
, 1);
461 BLKDBG_EVENT(bs
->file
, BLKDBG_READ_AIO
);
462 acb
->hd_aiocb
= bdrv_aio_readv(bs
->file
,
463 (acb
->cluster_offset
>> 9) + index_in_cluster
,
464 &acb
->hd_qiov
, acb
->cur_nr_sectors
,
465 qcow_aio_read_cb
, acb
);
466 if (acb
->hd_aiocb
== NULL
) {
474 if (acb
->qiov
->niov
> 1) {
475 qemu_iovec_from_buffer(acb
->qiov
, acb
->orig_buf
, acb
->qiov
->size
);
476 qemu_vfree(acb
->orig_buf
);
478 acb
->common
.cb(acb
->common
.opaque
, ret
);
479 qemu_aio_release(acb
);
482 static QCowAIOCB
*qcow_aio_setup(BlockDriverState
*bs
,
483 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
484 BlockDriverCompletionFunc
*cb
, void *opaque
, int is_write
)
488 acb
= qemu_aio_get(&qcow_aio_pool
, bs
, cb
, opaque
);
491 acb
->hd_aiocb
= NULL
;
492 acb
->sector_num
= sector_num
;
494 if (qiov
->niov
> 1) {
495 acb
->buf
= acb
->orig_buf
= qemu_blockalign(bs
, qiov
->size
);
497 qemu_iovec_to_buffer(qiov
, acb
->buf
);
499 acb
->buf
= (uint8_t *)qiov
->iov
->iov_base
;
501 acb
->remaining_sectors
= nb_sectors
;
502 acb
->cur_nr_sectors
= 0;
503 acb
->cluster_offset
= 0;
504 acb
->l2meta
.nb_clusters
= 0;
505 QLIST_INIT(&acb
->l2meta
.dependent_requests
);
509 static BlockDriverAIOCB
*qcow_aio_readv(BlockDriverState
*bs
,
510 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
511 BlockDriverCompletionFunc
*cb
, void *opaque
)
515 acb
= qcow_aio_setup(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 0);
519 qcow_aio_read_cb(acb
, 0);
523 static void qcow_aio_write_cb(void *opaque
, int ret
);
525 static void run_dependent_requests(QCowL2Meta
*m
)
530 /* Take the request off the list of running requests */
531 if (m
->nb_clusters
!= 0) {
532 QLIST_REMOVE(m
, next_in_flight
);
535 /* Restart all dependent requests */
536 QLIST_FOREACH_SAFE(req
, &m
->dependent_requests
, next_depend
, next
) {
537 qcow_aio_write_cb(req
, 0);
540 /* Empty the list for the next part of the request */
541 QLIST_INIT(&m
->dependent_requests
);
544 static void qcow_aio_write_cb(void *opaque
, int ret
)
546 QCowAIOCB
*acb
= opaque
;
547 BlockDriverState
*bs
= acb
->common
.bs
;
548 BDRVQcowState
*s
= bs
->opaque
;
549 int index_in_cluster
;
550 const uint8_t *src_buf
;
553 acb
->hd_aiocb
= NULL
;
556 ret
= qcow2_alloc_cluster_link_l2(bs
, &acb
->l2meta
);
559 run_dependent_requests(&acb
->l2meta
);
564 acb
->remaining_sectors
-= acb
->cur_nr_sectors
;
565 acb
->sector_num
+= acb
->cur_nr_sectors
;
566 acb
->buf
+= acb
->cur_nr_sectors
* 512;
568 if (acb
->remaining_sectors
== 0) {
569 /* request completed */
574 index_in_cluster
= acb
->sector_num
& (s
->cluster_sectors
- 1);
575 n_end
= index_in_cluster
+ acb
->remaining_sectors
;
576 if (s
->crypt_method
&&
577 n_end
> QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_sectors
)
578 n_end
= QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_sectors
;
580 ret
= qcow2_alloc_cluster_offset(bs
, acb
->sector_num
<< 9,
581 index_in_cluster
, n_end
, &acb
->cur_nr_sectors
, &acb
->l2meta
);
586 acb
->cluster_offset
= acb
->l2meta
.cluster_offset
;
588 /* Need to wait for another request? If so, we are done for now. */
589 if (acb
->l2meta
.nb_clusters
== 0 && acb
->l2meta
.depends_on
!= NULL
) {
590 QLIST_INSERT_HEAD(&acb
->l2meta
.depends_on
->dependent_requests
,
595 assert((acb
->cluster_offset
& 511) == 0);
597 if (s
->crypt_method
) {
598 if (!acb
->cluster_data
) {
599 acb
->cluster_data
= qemu_mallocz(QCOW_MAX_CRYPT_CLUSTERS
*
602 qcow2_encrypt_sectors(s
, acb
->sector_num
, acb
->cluster_data
, acb
->buf
,
603 acb
->cur_nr_sectors
, 1, &s
->aes_encrypt_key
);
604 src_buf
= acb
->cluster_data
;
608 acb
->hd_iov
.iov_base
= (void *)src_buf
;
609 acb
->hd_iov
.iov_len
= acb
->cur_nr_sectors
* 512;
610 qemu_iovec_init_external(&acb
->hd_qiov
, &acb
->hd_iov
, 1);
611 BLKDBG_EVENT(bs
->file
, BLKDBG_WRITE_AIO
);
612 acb
->hd_aiocb
= bdrv_aio_writev(bs
->file
,
613 (acb
->cluster_offset
>> 9) + index_in_cluster
,
614 &acb
->hd_qiov
, acb
->cur_nr_sectors
,
615 qcow_aio_write_cb
, acb
);
616 if (acb
->hd_aiocb
== NULL
) {
624 if (acb
->l2meta
.nb_clusters
!= 0) {
625 QLIST_REMOVE(&acb
->l2meta
, next_in_flight
);
628 if (acb
->qiov
->niov
> 1)
629 qemu_vfree(acb
->orig_buf
);
630 acb
->common
.cb(acb
->common
.opaque
, ret
);
631 qemu_aio_release(acb
);
634 static BlockDriverAIOCB
*qcow_aio_writev(BlockDriverState
*bs
,
635 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
636 BlockDriverCompletionFunc
*cb
, void *opaque
)
638 BDRVQcowState
*s
= bs
->opaque
;
641 s
->cluster_cache_offset
= -1; /* disable compressed cache */
643 acb
= qcow_aio_setup(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 1);
647 qcow_aio_write_cb(acb
, 0);
651 static void qcow_close(BlockDriverState
*bs
)
653 BDRVQcowState
*s
= bs
->opaque
;
654 qemu_free(s
->l1_table
);
655 qemu_free(s
->l2_cache
);
656 qemu_free(s
->cluster_cache
);
657 qemu_free(s
->cluster_data
);
658 qcow2_refcount_close(bs
);
662 * Updates the variable length parts of the qcow2 header, i.e. the backing file
663 * name and all extensions. qcow2 was not designed to allow such changes, so if
664 * we run out of space (we can only use the first cluster) this function may
667 * Returns 0 on success, -errno in error cases.
669 static int qcow2_update_ext_header(BlockDriverState
*bs
,
670 const char *backing_file
, const char *backing_fmt
)
672 size_t backing_file_len
= 0;
673 size_t backing_fmt_len
= 0;
674 BDRVQcowState
*s
= bs
->opaque
;
675 QCowExtension ext_backing_fmt
= {0, 0};
678 /* Backing file format doesn't make sense without a backing file */
679 if (backing_fmt
&& !backing_file
) {
683 /* Prepare the backing file format extension if needed */
685 ext_backing_fmt
.len
= cpu_to_be32(strlen(backing_fmt
));
686 ext_backing_fmt
.magic
= cpu_to_be32(QCOW_EXT_MAGIC_BACKING_FORMAT
);
687 backing_fmt_len
= ((sizeof(ext_backing_fmt
)
688 + strlen(backing_fmt
) + 7) & ~7);
691 /* Check if we can fit the new header into the first cluster */
693 backing_file_len
= strlen(backing_file
);
696 size_t header_size
= sizeof(QCowHeader
) + backing_file_len
699 if (header_size
> s
->cluster_size
) {
703 /* Rewrite backing file name and qcow2 extensions */
704 size_t ext_size
= header_size
- sizeof(QCowHeader
);
705 uint8_t buf
[ext_size
];
707 size_t backing_file_offset
= 0;
711 int padding
= backing_fmt_len
-
712 (sizeof(ext_backing_fmt
) + strlen(backing_fmt
));
714 memcpy(buf
+ offset
, &ext_backing_fmt
, sizeof(ext_backing_fmt
));
715 offset
+= sizeof(ext_backing_fmt
);
717 memcpy(buf
+ offset
, backing_fmt
, strlen(backing_fmt
));
718 offset
+= strlen(backing_fmt
);
720 memset(buf
+ offset
, 0, padding
);
724 memcpy(buf
+ offset
, backing_file
, backing_file_len
);
725 backing_file_offset
= sizeof(QCowHeader
) + offset
;
728 ret
= bdrv_pwrite(bs
->file
, sizeof(QCowHeader
), buf
, ext_size
);
733 /* Update header fields */
734 uint64_t be_backing_file_offset
= cpu_to_be64(backing_file_offset
);
735 uint32_t be_backing_file_size
= cpu_to_be32(backing_file_len
);
737 ret
= bdrv_pwrite(bs
->file
, offsetof(QCowHeader
, backing_file_offset
),
738 &be_backing_file_offset
, sizeof(uint64_t));
743 ret
= bdrv_pwrite(bs
->file
, offsetof(QCowHeader
, backing_file_size
),
744 &be_backing_file_size
, sizeof(uint32_t));
754 static int qcow2_change_backing_file(BlockDriverState
*bs
,
755 const char *backing_file
, const char *backing_fmt
)
757 return qcow2_update_ext_header(bs
, backing_file
, backing_fmt
);
760 static int get_bits_from_size(size_t size
)
769 /* Not a power of two */
782 static int preallocate(BlockDriverState
*bs
)
790 nb_sectors
= bdrv_getlength(bs
) >> 9;
792 QLIST_INIT(&meta
.dependent_requests
);
793 meta
.cluster_offset
= 0;
796 num
= MIN(nb_sectors
, INT_MAX
>> 9);
797 ret
= qcow2_alloc_cluster_offset(bs
, offset
, 0, num
, &num
, &meta
);
803 if (qcow2_alloc_cluster_link_l2(bs
, &meta
) < 0) {
804 qcow2_free_any_clusters(bs
, meta
.cluster_offset
, meta
.nb_clusters
);
808 /* There are no dependent requests, but we need to remove our request
809 * from the list of in-flight requests */
810 run_dependent_requests(&meta
);
812 /* TODO Preallocate data if requested */
819 * It is expected that the image file is large enough to actually contain
820 * all of the allocated clusters (otherwise we get failing reads after
821 * EOF). Extend the image to the last allocated sector.
823 if (meta
.cluster_offset
!= 0) {
826 bdrv_write(bs
->file
, (meta
.cluster_offset
>> 9) + num
- 1, buf
, 1);
832 static int qcow_create2(const char *filename
, int64_t total_size
,
833 const char *backing_file
, const char *backing_format
,
834 int flags
, size_t cluster_size
, int prealloc
)
837 int fd
, header_size
, backing_filename_len
, l1_size
, i
, shift
, l2_bits
;
838 int ref_clusters
, reftable_clusters
, backing_format_len
= 0;
839 int rounded_ext_bf_len
= 0;
841 uint64_t tmp
, offset
;
842 uint64_t old_ref_clusters
;
843 QCowCreateState s1
, *s
= &s1
;
844 QCowExtension ext_bf
= {0, 0};
847 memset(s
, 0, sizeof(*s
));
849 fd
= open(filename
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_BINARY
, 0644);
852 memset(&header
, 0, sizeof(header
));
853 header
.magic
= cpu_to_be32(QCOW_MAGIC
);
854 header
.version
= cpu_to_be32(QCOW_VERSION
);
855 header
.size
= cpu_to_be64(total_size
* 512);
856 header_size
= sizeof(header
);
857 backing_filename_len
= 0;
859 if (backing_format
) {
860 ext_bf
.magic
= QCOW_EXT_MAGIC_BACKING_FORMAT
;
861 backing_format_len
= strlen(backing_format
);
862 ext_bf
.len
= backing_format_len
;
863 rounded_ext_bf_len
= (sizeof(ext_bf
) + ext_bf
.len
+ 7) & ~7;
864 header_size
+= rounded_ext_bf_len
;
866 header
.backing_file_offset
= cpu_to_be64(header_size
);
867 backing_filename_len
= strlen(backing_file
);
868 header
.backing_file_size
= cpu_to_be32(backing_filename_len
);
869 header_size
+= backing_filename_len
;
873 s
->cluster_bits
= get_bits_from_size(cluster_size
);
874 if (s
->cluster_bits
< MIN_CLUSTER_BITS
||
875 s
->cluster_bits
> MAX_CLUSTER_BITS
)
877 fprintf(stderr
, "Cluster size must be a power of two between "
879 1 << MIN_CLUSTER_BITS
,
880 1 << (MAX_CLUSTER_BITS
- 10));
883 s
->cluster_size
= 1 << s
->cluster_bits
;
885 header
.cluster_bits
= cpu_to_be32(s
->cluster_bits
);
886 header_size
= (header_size
+ 7) & ~7;
887 if (flags
& BLOCK_FLAG_ENCRYPT
) {
888 header
.crypt_method
= cpu_to_be32(QCOW_CRYPT_AES
);
890 header
.crypt_method
= cpu_to_be32(QCOW_CRYPT_NONE
);
892 l2_bits
= s
->cluster_bits
- 3;
893 shift
= s
->cluster_bits
+ l2_bits
;
894 l1_size
= (((total_size
* 512) + (1LL << shift
) - 1) >> shift
);
895 offset
= align_offset(header_size
, s
->cluster_size
);
896 s
->l1_table_offset
= offset
;
897 header
.l1_table_offset
= cpu_to_be64(s
->l1_table_offset
);
898 header
.l1_size
= cpu_to_be32(l1_size
);
899 offset
+= align_offset(l1_size
* sizeof(uint64_t), s
->cluster_size
);
901 /* count how many refcount blocks needed */
903 #define NUM_CLUSTERS(bytes) \
904 (((bytes) + (s->cluster_size) - 1) / (s->cluster_size))
906 ref_clusters
= NUM_CLUSTERS(NUM_CLUSTERS(offset
) * sizeof(uint16_t));
909 uint64_t image_clusters
;
910 old_ref_clusters
= ref_clusters
;
912 /* Number of clusters used for the refcount table */
913 reftable_clusters
= NUM_CLUSTERS(ref_clusters
* sizeof(uint64_t));
915 /* Number of clusters that the whole image will have */
916 image_clusters
= NUM_CLUSTERS(offset
) + ref_clusters
919 /* Number of refcount blocks needed for the image */
920 ref_clusters
= NUM_CLUSTERS(image_clusters
* sizeof(uint16_t));
922 } while (ref_clusters
!= old_ref_clusters
);
924 s
->refcount_table
= qemu_mallocz(reftable_clusters
* s
->cluster_size
);
926 s
->refcount_table_offset
= offset
;
927 header
.refcount_table_offset
= cpu_to_be64(offset
);
928 header
.refcount_table_clusters
= cpu_to_be32(reftable_clusters
);
929 offset
+= (reftable_clusters
* s
->cluster_size
);
930 s
->refcount_block_offset
= offset
;
932 for (i
=0; i
< ref_clusters
; i
++) {
933 s
->refcount_table
[i
] = cpu_to_be64(offset
);
934 offset
+= s
->cluster_size
;
937 s
->refcount_block
= qemu_mallocz(ref_clusters
* s
->cluster_size
);
939 /* update refcounts */
940 qcow2_create_refcount_update(s
, 0, header_size
);
941 qcow2_create_refcount_update(s
, s
->l1_table_offset
,
942 l1_size
* sizeof(uint64_t));
943 qcow2_create_refcount_update(s
, s
->refcount_table_offset
,
944 reftable_clusters
* s
->cluster_size
);
945 qcow2_create_refcount_update(s
, s
->refcount_block_offset
,
946 ref_clusters
* s
->cluster_size
);
948 /* write all the data */
949 ret
= qemu_write_full(fd
, &header
, sizeof(header
));
950 if (ret
!= sizeof(header
)) {
955 if (backing_format_len
) {
957 int padding
= rounded_ext_bf_len
- (ext_bf
.len
+ sizeof(ext_bf
));
959 memset(zero
, 0, sizeof(zero
));
960 cpu_to_be32s(&ext_bf
.magic
);
961 cpu_to_be32s(&ext_bf
.len
);
962 ret
= qemu_write_full(fd
, &ext_bf
, sizeof(ext_bf
));
963 if (ret
!= sizeof(ext_bf
)) {
967 ret
= qemu_write_full(fd
, backing_format
, backing_format_len
);
968 if (ret
!= backing_format_len
) {
973 ret
= qemu_write_full(fd
, zero
, padding
);
974 if (ret
!= padding
) {
980 ret
= qemu_write_full(fd
, backing_file
, backing_filename_len
);
981 if (ret
!= backing_filename_len
) {
986 lseek(fd
, s
->l1_table_offset
, SEEK_SET
);
988 for(i
= 0;i
< l1_size
; i
++) {
989 ret
= qemu_write_full(fd
, &tmp
, sizeof(tmp
));
990 if (ret
!= sizeof(tmp
)) {
995 lseek(fd
, s
->refcount_table_offset
, SEEK_SET
);
996 ret
= qemu_write_full(fd
, s
->refcount_table
,
997 reftable_clusters
* s
->cluster_size
);
998 if (ret
!= reftable_clusters
* s
->cluster_size
) {
1003 lseek(fd
, s
->refcount_block_offset
, SEEK_SET
);
1004 ret
= qemu_write_full(fd
, s
->refcount_block
,
1005 ref_clusters
* s
->cluster_size
);
1006 if (ret
!= ref_clusters
* s
->cluster_size
) {
1013 qemu_free(s
->refcount_table
);
1014 qemu_free(s
->refcount_block
);
1017 /* Preallocate metadata */
1018 if (ret
== 0 && prealloc
) {
1019 BlockDriverState
*bs
;
1020 BlockDriver
*drv
= bdrv_find_format("qcow2");
1022 bdrv_open(bs
, filename
, BDRV_O_CACHE_WB
| BDRV_O_RDWR
, drv
);
1030 static int qcow_create(const char *filename
, QEMUOptionParameter
*options
)
1032 const char *backing_file
= NULL
;
1033 const char *backing_fmt
= NULL
;
1034 uint64_t sectors
= 0;
1036 size_t cluster_size
= 65536;
1039 /* Read out options */
1040 while (options
&& options
->name
) {
1041 if (!strcmp(options
->name
, BLOCK_OPT_SIZE
)) {
1042 sectors
= options
->value
.n
/ 512;
1043 } else if (!strcmp(options
->name
, BLOCK_OPT_BACKING_FILE
)) {
1044 backing_file
= options
->value
.s
;
1045 } else if (!strcmp(options
->name
, BLOCK_OPT_BACKING_FMT
)) {
1046 backing_fmt
= options
->value
.s
;
1047 } else if (!strcmp(options
->name
, BLOCK_OPT_ENCRYPT
)) {
1048 flags
|= options
->value
.n
? BLOCK_FLAG_ENCRYPT
: 0;
1049 } else if (!strcmp(options
->name
, BLOCK_OPT_CLUSTER_SIZE
)) {
1050 if (options
->value
.n
) {
1051 cluster_size
= options
->value
.n
;
1053 } else if (!strcmp(options
->name
, BLOCK_OPT_PREALLOC
)) {
1054 if (!options
->value
.s
|| !strcmp(options
->value
.s
, "off")) {
1056 } else if (!strcmp(options
->value
.s
, "metadata")) {
1059 fprintf(stderr
, "Invalid preallocation mode: '%s'\n",
1067 if (backing_file
&& prealloc
) {
1068 fprintf(stderr
, "Backing file and preallocation cannot be used at "
1073 return qcow_create2(filename
, sectors
, backing_file
, backing_fmt
, flags
,
1074 cluster_size
, prealloc
);
1077 static int qcow_make_empty(BlockDriverState
*bs
)
1080 /* XXX: not correct */
1081 BDRVQcowState
*s
= bs
->opaque
;
1082 uint32_t l1_length
= s
->l1_size
* sizeof(uint64_t);
1085 memset(s
->l1_table
, 0, l1_length
);
1086 if (bdrv_pwrite(bs
->file
, s
->l1_table_offset
, s
->l1_table
, l1_length
) < 0)
1088 ret
= bdrv_truncate(bs
->file
, s
->l1_table_offset
+ l1_length
);
1097 static int qcow2_truncate(BlockDriverState
*bs
, int64_t offset
)
1099 BDRVQcowState
*s
= bs
->opaque
;
1100 int ret
, new_l1_size
;
1106 /* cannot proceed if image has snapshots */
1107 if (s
->nb_snapshots
) {
1111 /* shrinking is currently not supported */
1112 if (offset
< bs
->total_sectors
* 512) {
1116 new_l1_size
= size_to_l1(s
, offset
);
1117 ret
= qcow2_grow_l1_table(bs
, new_l1_size
);
1122 /* write updated header.size */
1123 offset
= cpu_to_be64(offset
);
1124 ret
= bdrv_pwrite(bs
->file
, offsetof(QCowHeader
, size
),
1125 &offset
, sizeof(uint64_t));
1130 s
->l1_vm_state_index
= new_l1_size
;
1134 /* XXX: put compressed sectors first, then all the cluster aligned
1135 tables to avoid losing bytes in alignment */
1136 static int qcow_write_compressed(BlockDriverState
*bs
, int64_t sector_num
,
1137 const uint8_t *buf
, int nb_sectors
)
1139 BDRVQcowState
*s
= bs
->opaque
;
1143 uint64_t cluster_offset
;
1145 if (nb_sectors
== 0) {
1146 /* align end of file to a sector boundary to ease reading with
1147 sector based I/Os */
1148 cluster_offset
= bdrv_getlength(bs
->file
);
1149 cluster_offset
= (cluster_offset
+ 511) & ~511;
1150 bdrv_truncate(bs
->file
, cluster_offset
);
1154 if (nb_sectors
!= s
->cluster_sectors
)
1157 out_buf
= qemu_malloc(s
->cluster_size
+ (s
->cluster_size
/ 1000) + 128);
1159 /* best compression, small window, no zlib header */
1160 memset(&strm
, 0, sizeof(strm
));
1161 ret
= deflateInit2(&strm
, Z_DEFAULT_COMPRESSION
,
1163 9, Z_DEFAULT_STRATEGY
);
1169 strm
.avail_in
= s
->cluster_size
;
1170 strm
.next_in
= (uint8_t *)buf
;
1171 strm
.avail_out
= s
->cluster_size
;
1172 strm
.next_out
= out_buf
;
1174 ret
= deflate(&strm
, Z_FINISH
);
1175 if (ret
!= Z_STREAM_END
&& ret
!= Z_OK
) {
1180 out_len
= strm
.next_out
- out_buf
;
1184 if (ret
!= Z_STREAM_END
|| out_len
>= s
->cluster_size
) {
1185 /* could not compress: write normal cluster */
1186 bdrv_write(bs
, sector_num
, buf
, s
->cluster_sectors
);
1188 cluster_offset
= qcow2_alloc_compressed_cluster_offset(bs
,
1189 sector_num
<< 9, out_len
);
1190 if (!cluster_offset
)
1192 cluster_offset
&= s
->cluster_offset_mask
;
1193 BLKDBG_EVENT(bs
->file
, BLKDBG_WRITE_COMPRESSED
);
1194 if (bdrv_pwrite(bs
->file
, cluster_offset
, out_buf
, out_len
) != out_len
) {
1204 static void qcow_flush(BlockDriverState
*bs
)
1206 bdrv_flush(bs
->file
);
1209 static BlockDriverAIOCB
*qcow_aio_flush(BlockDriverState
*bs
,
1210 BlockDriverCompletionFunc
*cb
, void *opaque
)
1212 return bdrv_aio_flush(bs
->file
, cb
, opaque
);
1215 static int64_t qcow_vm_state_offset(BDRVQcowState
*s
)
1217 return (int64_t)s
->l1_vm_state_index
<< (s
->cluster_bits
+ s
->l2_bits
);
1220 static int qcow_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
1222 BDRVQcowState
*s
= bs
->opaque
;
1223 bdi
->cluster_size
= s
->cluster_size
;
1224 bdi
->vm_state_offset
= qcow_vm_state_offset(s
);
1229 static int qcow_check(BlockDriverState
*bs
)
1231 return qcow2_check_refcounts(bs
);
1235 static void dump_refcounts(BlockDriverState
*bs
)
1237 BDRVQcowState
*s
= bs
->opaque
;
1238 int64_t nb_clusters
, k
, k1
, size
;
1241 size
= bdrv_getlength(bs
->file
);
1242 nb_clusters
= size_to_clusters(s
, size
);
1243 for(k
= 0; k
< nb_clusters
;) {
1245 refcount
= get_refcount(bs
, k
);
1247 while (k
< nb_clusters
&& get_refcount(bs
, k
) == refcount
)
1249 printf("%" PRId64
": refcount=%d nb=%" PRId64
"\n", k
, refcount
,
1255 static int qcow_save_vmstate(BlockDriverState
*bs
, const uint8_t *buf
,
1256 int64_t pos
, int size
)
1258 BDRVQcowState
*s
= bs
->opaque
;
1259 int growable
= bs
->growable
;
1262 BLKDBG_EVENT(bs
->file
, BLKDBG_VMSTATE_SAVE
);
1264 ret
= bdrv_pwrite(bs
, qcow_vm_state_offset(s
) + pos
, buf
, size
);
1265 bs
->growable
= growable
;
1270 static int qcow_load_vmstate(BlockDriverState
*bs
, uint8_t *buf
,
1271 int64_t pos
, int size
)
1273 BDRVQcowState
*s
= bs
->opaque
;
1274 int growable
= bs
->growable
;
1277 BLKDBG_EVENT(bs
->file
, BLKDBG_VMSTATE_LOAD
);
1279 ret
= bdrv_pread(bs
, qcow_vm_state_offset(s
) + pos
, buf
, size
);
1280 bs
->growable
= growable
;
1285 static QEMUOptionParameter qcow_create_options
[] = {
1287 .name
= BLOCK_OPT_SIZE
,
1289 .help
= "Virtual disk size"
1292 .name
= BLOCK_OPT_BACKING_FILE
,
1294 .help
= "File name of a base image"
1297 .name
= BLOCK_OPT_BACKING_FMT
,
1299 .help
= "Image format of the base image"
1302 .name
= BLOCK_OPT_ENCRYPT
,
1304 .help
= "Encrypt the image"
1307 .name
= BLOCK_OPT_CLUSTER_SIZE
,
1309 .help
= "qcow2 cluster size"
1312 .name
= BLOCK_OPT_PREALLOC
,
1314 .help
= "Preallocation mode (allowed values: off, metadata)"
1319 static BlockDriver bdrv_qcow2
= {
1320 .format_name
= "qcow2",
1321 .instance_size
= sizeof(BDRVQcowState
),
1322 .bdrv_probe
= qcow_probe
,
1323 .bdrv_open
= qcow_open
,
1324 .bdrv_close
= qcow_close
,
1325 .bdrv_create
= qcow_create
,
1326 .bdrv_flush
= qcow_flush
,
1327 .bdrv_is_allocated
= qcow_is_allocated
,
1328 .bdrv_set_key
= qcow_set_key
,
1329 .bdrv_make_empty
= qcow_make_empty
,
1331 .bdrv_aio_readv
= qcow_aio_readv
,
1332 .bdrv_aio_writev
= qcow_aio_writev
,
1333 .bdrv_aio_flush
= qcow_aio_flush
,
1335 .bdrv_truncate
= qcow2_truncate
,
1336 .bdrv_write_compressed
= qcow_write_compressed
,
1338 .bdrv_snapshot_create
= qcow2_snapshot_create
,
1339 .bdrv_snapshot_goto
= qcow2_snapshot_goto
,
1340 .bdrv_snapshot_delete
= qcow2_snapshot_delete
,
1341 .bdrv_snapshot_list
= qcow2_snapshot_list
,
1342 .bdrv_get_info
= qcow_get_info
,
1344 .bdrv_save_vmstate
= qcow_save_vmstate
,
1345 .bdrv_load_vmstate
= qcow_load_vmstate
,
1347 .bdrv_change_backing_file
= qcow2_change_backing_file
,
1349 .create_options
= qcow_create_options
,
1350 .bdrv_check
= qcow_check
,
1353 static void bdrv_qcow2_init(void)
1355 bdrv_register(&bdrv_qcow2
);
1358 block_init(bdrv_qcow2_init
);