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"
31 Differences with QCOW:
33 - Support for multiple incremental snapshots.
34 - Memory management by reference counts.
35 - Clusters which have a reference count of one have the bit
36 QCOW_OFLAG_COPIED to optimize write performance.
37 - Size of compressed clusters is stored in sectors to reduce bit usage
38 in the cluster offsets.
39 - Support for storing additional data (such as the VM state) in the
41 - If a backing store is used, the cluster size is not constrained
42 (could be backported to QCOW).
43 - L2 tables have always a size of one cluster.
47 //#define DEBUG_ALLOC2
49 #define QCOW_MAGIC (('Q' << 24) | ('F' << 16) | ('I' << 8) | 0xfb)
50 #define QCOW_VERSION 2
52 #define QCOW_CRYPT_NONE 0
53 #define QCOW_CRYPT_AES 1
55 #define QCOW_MAX_CRYPT_CLUSTERS 32
57 /* indicate that the refcount of the referenced cluster is exactly one. */
58 #define QCOW_OFLAG_COPIED (1LL << 63)
59 /* indicate that the cluster is compressed (they never have the copied flag) */
60 #define QCOW_OFLAG_COMPRESSED (1LL << 62)
62 #define REFCOUNT_SHIFT 1 /* refcount size is 2 bytes */
64 typedef struct QCowHeader
{
67 uint64_t backing_file_offset
;
68 uint32_t backing_file_size
;
69 uint32_t cluster_bits
;
70 uint64_t size
; /* in bytes */
71 uint32_t crypt_method
;
72 uint32_t l1_size
; /* XXX: save number of clusters instead ? */
73 uint64_t l1_table_offset
;
74 uint64_t refcount_table_offset
;
75 uint32_t refcount_table_clusters
;
76 uint32_t nb_snapshots
;
77 uint64_t snapshots_offset
;
80 typedef struct __attribute__((packed
)) QCowSnapshotHeader
{
81 /* header is 8 byte aligned */
82 uint64_t l1_table_offset
;
91 uint64_t vm_clock_nsec
;
93 uint32_t vm_state_size
;
94 uint32_t extra_data_size
; /* for extension */
95 /* extra data follows */
100 #define L2_CACHE_SIZE 16
102 typedef struct QCowSnapshot
{
103 uint64_t l1_table_offset
;
107 uint32_t vm_state_size
;
110 uint64_t vm_clock_nsec
;
113 typedef struct BDRVQcowState
{
114 BlockDriverState
*hd
;
121 int l1_vm_state_index
;
124 uint64_t cluster_offset_mask
;
125 uint64_t l1_table_offset
;
128 uint64_t l2_cache_offsets
[L2_CACHE_SIZE
];
129 uint32_t l2_cache_counts
[L2_CACHE_SIZE
];
130 uint8_t *cluster_cache
;
131 uint8_t *cluster_data
;
132 uint64_t cluster_cache_offset
;
134 uint64_t *refcount_table
;
135 uint64_t refcount_table_offset
;
136 uint32_t refcount_table_size
;
137 uint64_t refcount_block_cache_offset
;
138 uint16_t *refcount_block_cache
;
139 int64_t free_cluster_index
;
140 int64_t free_byte_offset
;
142 uint32_t crypt_method
; /* current crypt method, 0 if no key yet */
143 uint32_t crypt_method_header
;
144 AES_KEY aes_encrypt_key
;
145 AES_KEY aes_decrypt_key
;
146 uint64_t snapshots_offset
;
149 QCowSnapshot
*snapshots
;
152 static int decompress_cluster(BDRVQcowState
*s
, uint64_t cluster_offset
);
153 static int qcow_read(BlockDriverState
*bs
, int64_t sector_num
,
154 uint8_t *buf
, int nb_sectors
);
155 static int qcow_read_snapshots(BlockDriverState
*bs
);
156 static void qcow_free_snapshots(BlockDriverState
*bs
);
157 static int refcount_init(BlockDriverState
*bs
);
158 static void refcount_close(BlockDriverState
*bs
);
159 static int get_refcount(BlockDriverState
*bs
, int64_t cluster_index
);
160 static int update_cluster_refcount(BlockDriverState
*bs
,
161 int64_t cluster_index
,
163 static void update_refcount(BlockDriverState
*bs
,
164 int64_t offset
, int64_t length
,
166 static int64_t alloc_clusters(BlockDriverState
*bs
, int64_t size
);
167 static int64_t alloc_bytes(BlockDriverState
*bs
, int size
);
168 static void free_clusters(BlockDriverState
*bs
,
169 int64_t offset
, int64_t size
);
171 static void check_refcounts(BlockDriverState
*bs
);
174 static int qcow_probe(const uint8_t *buf
, int buf_size
, const char *filename
)
176 const QCowHeader
*cow_header
= (const void *)buf
;
178 if (buf_size
>= sizeof(QCowHeader
) &&
179 be32_to_cpu(cow_header
->magic
) == QCOW_MAGIC
&&
180 be32_to_cpu(cow_header
->version
) == QCOW_VERSION
)
186 static int qcow_open(BlockDriverState
*bs
, const char *filename
, int flags
)
188 BDRVQcowState
*s
= bs
->opaque
;
189 int len
, i
, shift
, ret
;
192 ret
= bdrv_file_open(&s
->hd
, filename
, flags
);
195 if (bdrv_pread(s
->hd
, 0, &header
, sizeof(header
)) != sizeof(header
))
197 be32_to_cpus(&header
.magic
);
198 be32_to_cpus(&header
.version
);
199 be64_to_cpus(&header
.backing_file_offset
);
200 be32_to_cpus(&header
.backing_file_size
);
201 be64_to_cpus(&header
.size
);
202 be32_to_cpus(&header
.cluster_bits
);
203 be32_to_cpus(&header
.crypt_method
);
204 be64_to_cpus(&header
.l1_table_offset
);
205 be32_to_cpus(&header
.l1_size
);
206 be64_to_cpus(&header
.refcount_table_offset
);
207 be32_to_cpus(&header
.refcount_table_clusters
);
208 be64_to_cpus(&header
.snapshots_offset
);
209 be32_to_cpus(&header
.nb_snapshots
);
211 if (header
.magic
!= QCOW_MAGIC
|| header
.version
!= QCOW_VERSION
)
213 if (header
.size
<= 1 ||
214 header
.cluster_bits
< 9 ||
215 header
.cluster_bits
> 16)
217 if (header
.crypt_method
> QCOW_CRYPT_AES
)
219 s
->crypt_method_header
= header
.crypt_method
;
220 if (s
->crypt_method_header
)
222 s
->cluster_bits
= header
.cluster_bits
;
223 s
->cluster_size
= 1 << s
->cluster_bits
;
224 s
->cluster_sectors
= 1 << (s
->cluster_bits
- 9);
225 s
->l2_bits
= s
->cluster_bits
- 3; /* L2 is always one cluster */
226 s
->l2_size
= 1 << s
->l2_bits
;
227 bs
->total_sectors
= header
.size
/ 512;
228 s
->csize_shift
= (62 - (s
->cluster_bits
- 8));
229 s
->csize_mask
= (1 << (s
->cluster_bits
- 8)) - 1;
230 s
->cluster_offset_mask
= (1LL << s
->csize_shift
) - 1;
231 s
->refcount_table_offset
= header
.refcount_table_offset
;
232 s
->refcount_table_size
=
233 header
.refcount_table_clusters
<< (s
->cluster_bits
- 3);
235 s
->snapshots_offset
= header
.snapshots_offset
;
236 s
->nb_snapshots
= header
.nb_snapshots
;
238 /* read the level 1 table */
239 s
->l1_size
= header
.l1_size
;
240 shift
= s
->cluster_bits
+ s
->l2_bits
;
241 s
->l1_vm_state_index
= (header
.size
+ (1LL << shift
) - 1) >> shift
;
242 /* the L1 table must contain at least enough entries to put
244 if (s
->l1_size
< s
->l1_vm_state_index
)
246 s
->l1_table_offset
= header
.l1_table_offset
;
247 s
->l1_table
= qemu_malloc(s
->l1_size
* sizeof(uint64_t));
250 if (bdrv_pread(s
->hd
, s
->l1_table_offset
, s
->l1_table
, s
->l1_size
* sizeof(uint64_t)) !=
251 s
->l1_size
* sizeof(uint64_t))
253 for(i
= 0;i
< s
->l1_size
; i
++) {
254 be64_to_cpus(&s
->l1_table
[i
]);
257 s
->l2_cache
= qemu_malloc(s
->l2_size
* L2_CACHE_SIZE
* sizeof(uint64_t));
260 s
->cluster_cache
= qemu_malloc(s
->cluster_size
);
261 if (!s
->cluster_cache
)
263 /* one more sector for decompressed data alignment */
264 s
->cluster_data
= qemu_malloc(QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
266 if (!s
->cluster_data
)
268 s
->cluster_cache_offset
= -1;
270 if (refcount_init(bs
) < 0)
273 /* read the backing file name */
274 if (header
.backing_file_offset
!= 0) {
275 len
= header
.backing_file_size
;
278 if (bdrv_pread(s
->hd
, header
.backing_file_offset
, bs
->backing_file
, len
) != len
)
280 bs
->backing_file
[len
] = '\0';
282 if (qcow_read_snapshots(bs
) < 0)
291 qcow_free_snapshots(bs
);
293 qemu_free(s
->l1_table
);
294 qemu_free(s
->l2_cache
);
295 qemu_free(s
->cluster_cache
);
296 qemu_free(s
->cluster_data
);
301 static int qcow_set_key(BlockDriverState
*bs
, const char *key
)
303 BDRVQcowState
*s
= bs
->opaque
;
307 memset(keybuf
, 0, 16);
311 /* XXX: we could compress the chars to 7 bits to increase
313 for(i
= 0;i
< len
;i
++) {
316 s
->crypt_method
= s
->crypt_method_header
;
318 if (AES_set_encrypt_key(keybuf
, 128, &s
->aes_encrypt_key
) != 0)
320 if (AES_set_decrypt_key(keybuf
, 128, &s
->aes_decrypt_key
) != 0)
330 AES_encrypt(in
, tmp
, &s
->aes_encrypt_key
);
331 AES_decrypt(tmp
, out
, &s
->aes_decrypt_key
);
332 for(i
= 0; i
< 16; i
++)
333 printf(" %02x", tmp
[i
]);
335 for(i
= 0; i
< 16; i
++)
336 printf(" %02x", out
[i
]);
343 /* The crypt function is compatible with the linux cryptoloop
344 algorithm for < 4 GB images. NOTE: out_buf == in_buf is
346 static void encrypt_sectors(BDRVQcowState
*s
, int64_t sector_num
,
347 uint8_t *out_buf
, const uint8_t *in_buf
,
348 int nb_sectors
, int enc
,
357 for(i
= 0; i
< nb_sectors
; i
++) {
358 ivec
.ll
[0] = cpu_to_le64(sector_num
);
360 AES_cbc_encrypt(in_buf
, out_buf
, 512, key
,
368 static int copy_sectors(BlockDriverState
*bs
, uint64_t start_sect
,
369 uint64_t cluster_offset
, int n_start
, int n_end
)
371 BDRVQcowState
*s
= bs
->opaque
;
377 ret
= qcow_read(bs
, start_sect
+ n_start
, s
->cluster_data
, n
);
380 if (s
->crypt_method
) {
381 encrypt_sectors(s
, start_sect
+ n_start
,
383 s
->cluster_data
, n
, 1,
384 &s
->aes_encrypt_key
);
386 ret
= bdrv_write(s
->hd
, (cluster_offset
>> 9) + n_start
,
393 static void l2_cache_reset(BlockDriverState
*bs
)
395 BDRVQcowState
*s
= bs
->opaque
;
397 memset(s
->l2_cache
, 0, s
->l2_size
* L2_CACHE_SIZE
* sizeof(uint64_t));
398 memset(s
->l2_cache_offsets
, 0, L2_CACHE_SIZE
* sizeof(uint64_t));
399 memset(s
->l2_cache_counts
, 0, L2_CACHE_SIZE
* sizeof(uint32_t));
402 static inline int l2_cache_new_entry(BlockDriverState
*bs
)
404 BDRVQcowState
*s
= bs
->opaque
;
408 /* find a new entry in the least used one */
410 min_count
= 0xffffffff;
411 for(i
= 0; i
< L2_CACHE_SIZE
; i
++) {
412 if (s
->l2_cache_counts
[i
] < min_count
) {
413 min_count
= s
->l2_cache_counts
[i
];
420 static int64_t align_offset(int64_t offset
, int n
)
422 offset
= (offset
+ n
- 1) & ~(n
- 1);
426 static int grow_l1_table(BlockDriverState
*bs
, int min_size
)
428 BDRVQcowState
*s
= bs
->opaque
;
429 int new_l1_size
, new_l1_size2
, ret
, i
;
430 uint64_t *new_l1_table
;
431 uint64_t new_l1_table_offset
;
434 new_l1_size
= s
->l1_size
;
435 if (min_size
<= new_l1_size
)
437 while (min_size
> new_l1_size
) {
438 new_l1_size
= (new_l1_size
* 3 + 1) / 2;
441 printf("grow l1_table from %d to %d\n", s
->l1_size
, new_l1_size
);
444 new_l1_size2
= sizeof(uint64_t) * new_l1_size
;
445 new_l1_table
= qemu_mallocz(new_l1_size2
);
448 memcpy(new_l1_table
, s
->l1_table
, s
->l1_size
* sizeof(uint64_t));
450 /* write new table (align to cluster) */
451 new_l1_table_offset
= alloc_clusters(bs
, new_l1_size2
);
453 for(i
= 0; i
< s
->l1_size
; i
++)
454 new_l1_table
[i
] = cpu_to_be64(new_l1_table
[i
]);
455 ret
= bdrv_pwrite(s
->hd
, new_l1_table_offset
, new_l1_table
, new_l1_size2
);
456 if (ret
!= new_l1_size2
)
458 for(i
= 0; i
< s
->l1_size
; i
++)
459 new_l1_table
[i
] = be64_to_cpu(new_l1_table
[i
]);
462 cpu_to_be32w((uint32_t*)data
, new_l1_size
);
463 cpu_to_be64w((uint64_t*)(data
+ 4), new_l1_table_offset
);
464 if (bdrv_pwrite(s
->hd
, offsetof(QCowHeader
, l1_size
), data
,
465 sizeof(data
)) != sizeof(data
))
467 qemu_free(s
->l1_table
);
468 free_clusters(bs
, s
->l1_table_offset
, s
->l1_size
* sizeof(uint64_t));
469 s
->l1_table_offset
= new_l1_table_offset
;
470 s
->l1_table
= new_l1_table
;
471 s
->l1_size
= new_l1_size
;
474 qemu_free(s
->l1_table
);
481 * seek l2_offset in the l2_cache table
482 * if not found, return NULL,
484 * increments the l2 cache hit count of the entry,
485 * if counter overflow, divide by two all counters
486 * return the pointer to the l2 cache entry
490 static uint64_t *seek_l2_table(BDRVQcowState
*s
, uint64_t l2_offset
)
494 for(i
= 0; i
< L2_CACHE_SIZE
; i
++) {
495 if (l2_offset
== s
->l2_cache_offsets
[i
]) {
496 /* increment the hit count */
497 if (++s
->l2_cache_counts
[i
] == 0xffffffff) {
498 for(j
= 0; j
< L2_CACHE_SIZE
; j
++) {
499 s
->l2_cache_counts
[j
] >>= 1;
502 return s
->l2_cache
+ (i
<< s
->l2_bits
);
511 * Loads a L2 table into memory. If the table is in the cache, the cache
512 * is used; otherwise the L2 table is loaded from the image file.
514 * Returns a pointer to the L2 table on success, or NULL if the read from
515 * the image file failed.
518 static uint64_t *l2_load(BlockDriverState
*bs
, uint64_t l2_offset
)
520 BDRVQcowState
*s
= bs
->opaque
;
524 /* seek if the table for the given offset is in the cache */
526 l2_table
= seek_l2_table(s
, l2_offset
);
527 if (l2_table
!= NULL
)
530 /* not found: load a new entry in the least used one */
532 min_index
= l2_cache_new_entry(bs
);
533 l2_table
= s
->l2_cache
+ (min_index
<< s
->l2_bits
);
534 if (bdrv_pread(s
->hd
, l2_offset
, l2_table
, s
->l2_size
* sizeof(uint64_t)) !=
535 s
->l2_size
* sizeof(uint64_t))
537 s
->l2_cache_offsets
[min_index
] = l2_offset
;
538 s
->l2_cache_counts
[min_index
] = 1;
546 * Allocate a new l2 entry in the file. If l1_index points to an already
547 * used entry in the L2 table (i.e. we are doing a copy on write for the L2
548 * table) copy the contents of the old L2 table into the newly allocated one.
549 * Otherwise the new table is initialized with zeros.
553 static uint64_t *l2_allocate(BlockDriverState
*bs
, int l1_index
)
555 BDRVQcowState
*s
= bs
->opaque
;
557 uint64_t old_l2_offset
, tmp
;
558 uint64_t *l2_table
, l2_offset
;
560 old_l2_offset
= s
->l1_table
[l1_index
];
562 /* allocate a new l2 entry */
564 l2_offset
= alloc_clusters(bs
, s
->l2_size
* sizeof(uint64_t));
566 /* update the L1 entry */
568 s
->l1_table
[l1_index
] = l2_offset
| QCOW_OFLAG_COPIED
;
570 tmp
= cpu_to_be64(l2_offset
| QCOW_OFLAG_COPIED
);
571 if (bdrv_pwrite(s
->hd
, s
->l1_table_offset
+ l1_index
* sizeof(tmp
),
572 &tmp
, sizeof(tmp
)) != sizeof(tmp
))
575 /* allocate a new entry in the l2 cache */
577 min_index
= l2_cache_new_entry(bs
);
578 l2_table
= s
->l2_cache
+ (min_index
<< s
->l2_bits
);
580 if (old_l2_offset
== 0) {
581 /* if there was no old l2 table, clear the new table */
582 memset(l2_table
, 0, s
->l2_size
* sizeof(uint64_t));
584 /* if there was an old l2 table, read it from the disk */
585 if (bdrv_pread(s
->hd
, old_l2_offset
,
586 l2_table
, s
->l2_size
* sizeof(uint64_t)) !=
587 s
->l2_size
* sizeof(uint64_t))
590 /* write the l2 table to the file */
591 if (bdrv_pwrite(s
->hd
, l2_offset
,
592 l2_table
, s
->l2_size
* sizeof(uint64_t)) !=
593 s
->l2_size
* sizeof(uint64_t))
596 /* update the l2 cache entry */
598 s
->l2_cache_offsets
[min_index
] = l2_offset
;
599 s
->l2_cache_counts
[min_index
] = 1;
604 static int size_to_clusters(BDRVQcowState
*s
, int64_t size
)
606 return (size
+ (s
->cluster_size
- 1)) >> s
->cluster_bits
;
609 static int count_contiguous_clusters(uint64_t nb_clusters
, int cluster_size
,
610 uint64_t *l2_table
, uint64_t mask
)
613 uint64_t offset
= be64_to_cpu(l2_table
[0]) & ~mask
;
615 for (i
= 0; i
< nb_clusters
; i
++)
616 if (offset
+ i
* cluster_size
!= (be64_to_cpu(l2_table
[i
]) & ~mask
))
622 static int count_contiguous_free_clusters(uint64_t nb_clusters
, uint64_t *l2_table
)
626 while(nb_clusters
-- && l2_table
[i
] == 0)
635 * For a given offset of the disk image, return cluster offset in
638 * on entry, *num is the number of contiguous clusters we'd like to
639 * access following offset.
641 * on exit, *num is the number of contiguous clusters we can read.
643 * Return 1, if the offset is found
644 * Return 0, otherwise.
648 static uint64_t get_cluster_offset(BlockDriverState
*bs
,
649 uint64_t offset
, int *num
)
651 BDRVQcowState
*s
= bs
->opaque
;
652 int l1_index
, l2_index
;
653 uint64_t l2_offset
, *l2_table
, cluster_offset
;
655 int index_in_cluster
, nb_available
, nb_needed
, nb_clusters
;
657 index_in_cluster
= (offset
>> 9) & (s
->cluster_sectors
- 1);
658 nb_needed
= *num
+ index_in_cluster
;
660 l1_bits
= s
->l2_bits
+ s
->cluster_bits
;
662 /* compute how many bytes there are between the offset and
663 * the end of the l1 entry
666 nb_available
= (1 << l1_bits
) - (offset
& ((1 << l1_bits
) - 1));
668 /* compute the number of available sectors */
670 nb_available
= (nb_available
>> 9) + index_in_cluster
;
674 /* seek the the l2 offset in the l1 table */
676 l1_index
= offset
>> l1_bits
;
677 if (l1_index
>= s
->l1_size
)
680 l2_offset
= s
->l1_table
[l1_index
];
682 /* seek the l2 table of the given l2 offset */
687 /* load the l2 table in memory */
689 l2_offset
&= ~QCOW_OFLAG_COPIED
;
690 l2_table
= l2_load(bs
, l2_offset
);
691 if (l2_table
== NULL
)
694 /* find the cluster offset for the given disk offset */
696 l2_index
= (offset
>> s
->cluster_bits
) & (s
->l2_size
- 1);
697 cluster_offset
= be64_to_cpu(l2_table
[l2_index
]);
698 nb_clusters
= size_to_clusters(s
, nb_needed
<< 9);
700 if (!cluster_offset
) {
701 /* how many empty clusters ? */
702 c
= count_contiguous_free_clusters(nb_clusters
, &l2_table
[l2_index
]);
704 /* how many allocated clusters ? */
705 c
= count_contiguous_clusters(nb_clusters
, s
->cluster_size
,
706 &l2_table
[l2_index
], QCOW_OFLAG_COPIED
);
709 nb_available
= (c
* s
->cluster_sectors
);
711 if (nb_available
> nb_needed
)
712 nb_available
= nb_needed
;
714 *num
= nb_available
- index_in_cluster
;
716 return cluster_offset
& ~QCOW_OFLAG_COPIED
;
722 * free clusters according to its type: compressed or not
726 static void free_any_clusters(BlockDriverState
*bs
,
727 uint64_t cluster_offset
, int nb_clusters
)
729 BDRVQcowState
*s
= bs
->opaque
;
731 /* free the cluster */
733 if (cluster_offset
& QCOW_OFLAG_COMPRESSED
) {
735 nb_csectors
= ((cluster_offset
>> s
->csize_shift
) &
737 free_clusters(bs
, (cluster_offset
& s
->cluster_offset_mask
) & ~511,
742 free_clusters(bs
, cluster_offset
, nb_clusters
<< s
->cluster_bits
);
750 * for a given disk offset, load (and allocate if needed)
753 * the l2 table offset in the qcow2 file and the cluster index
754 * in the l2 table are given to the caller.
758 static int get_cluster_table(BlockDriverState
*bs
, uint64_t offset
,
759 uint64_t **new_l2_table
,
760 uint64_t *new_l2_offset
,
763 BDRVQcowState
*s
= bs
->opaque
;
764 int l1_index
, l2_index
, ret
;
765 uint64_t l2_offset
, *l2_table
;
767 /* seek the the l2 offset in the l1 table */
769 l1_index
= offset
>> (s
->l2_bits
+ s
->cluster_bits
);
770 if (l1_index
>= s
->l1_size
) {
771 ret
= grow_l1_table(bs
, l1_index
+ 1);
775 l2_offset
= s
->l1_table
[l1_index
];
777 /* seek the l2 table of the given l2 offset */
779 if (l2_offset
& QCOW_OFLAG_COPIED
) {
780 /* load the l2 table in memory */
781 l2_offset
&= ~QCOW_OFLAG_COPIED
;
782 l2_table
= l2_load(bs
, l2_offset
);
783 if (l2_table
== NULL
)
787 free_clusters(bs
, l2_offset
, s
->l2_size
* sizeof(uint64_t));
788 l2_table
= l2_allocate(bs
, l1_index
);
789 if (l2_table
== NULL
)
791 l2_offset
= s
->l1_table
[l1_index
] & ~QCOW_OFLAG_COPIED
;
794 /* find the cluster offset for the given disk offset */
796 l2_index
= (offset
>> s
->cluster_bits
) & (s
->l2_size
- 1);
798 *new_l2_table
= l2_table
;
799 *new_l2_offset
= l2_offset
;
800 *new_l2_index
= l2_index
;
806 * alloc_compressed_cluster_offset
808 * For a given offset of the disk image, return cluster offset in
811 * If the offset is not found, allocate a new compressed cluster.
813 * Return the cluster offset if successful,
814 * Return 0, otherwise.
818 static uint64_t alloc_compressed_cluster_offset(BlockDriverState
*bs
,
822 BDRVQcowState
*s
= bs
->opaque
;
824 uint64_t l2_offset
, *l2_table
, cluster_offset
;
827 ret
= get_cluster_table(bs
, offset
, &l2_table
, &l2_offset
, &l2_index
);
831 cluster_offset
= be64_to_cpu(l2_table
[l2_index
]);
832 if (cluster_offset
& QCOW_OFLAG_COPIED
)
833 return cluster_offset
& ~QCOW_OFLAG_COPIED
;
836 free_any_clusters(bs
, cluster_offset
, 1);
838 cluster_offset
= alloc_bytes(bs
, compressed_size
);
839 nb_csectors
= ((cluster_offset
+ compressed_size
- 1) >> 9) -
840 (cluster_offset
>> 9);
842 cluster_offset
|= QCOW_OFLAG_COMPRESSED
|
843 ((uint64_t)nb_csectors
<< s
->csize_shift
);
845 /* update L2 table */
847 /* compressed clusters never have the copied flag */
849 l2_table
[l2_index
] = cpu_to_be64(cluster_offset
);
850 if (bdrv_pwrite(s
->hd
,
851 l2_offset
+ l2_index
* sizeof(uint64_t),
853 sizeof(uint64_t)) != sizeof(uint64_t))
856 return cluster_offset
;
860 * alloc_cluster_offset
862 * For a given offset of the disk image, return cluster offset in
865 * If the offset is not found, allocate a new cluster.
867 * Return the cluster offset if successful,
868 * Return 0, otherwise.
872 static uint64_t alloc_cluster_offset(BlockDriverState
*bs
,
874 int n_start
, int n_end
,
877 BDRVQcowState
*s
= bs
->opaque
;
879 uint64_t l2_offset
, *l2_table
, cluster_offset
;
880 int nb_available
, nb_clusters
, i
= 0;
883 ret
= get_cluster_table(bs
, offset
, &l2_table
, &l2_offset
, &l2_index
);
887 nb_clusters
= size_to_clusters(s
, n_end
<< 9);
889 if (nb_clusters
> s
->l2_size
- l2_index
)
890 nb_clusters
= s
->l2_size
- l2_index
;
892 cluster_offset
= be64_to_cpu(l2_table
[l2_index
]);
894 /* We keep all QCOW_OFLAG_COPIED clusters */
896 if (cluster_offset
& QCOW_OFLAG_COPIED
) {
897 nb_clusters
= count_contiguous_clusters(nb_clusters
, s
->cluster_size
,
898 &l2_table
[l2_index
], 0);
900 nb_available
= nb_clusters
<< (s
->cluster_bits
- 9);
901 if (nb_available
> n_end
)
902 nb_available
= n_end
;
904 cluster_offset
&= ~QCOW_OFLAG_COPIED
;
909 /* for the moment, multiple compressed clusters are not managed */
911 if (cluster_offset
& QCOW_OFLAG_COMPRESSED
)
914 /* how many available clusters ? */
916 while (i
< nb_clusters
) {
918 i
+= count_contiguous_free_clusters(nb_clusters
- i
,
919 &l2_table
[l2_index
+ i
]);
921 cluster_offset
= be64_to_cpu(l2_table
[l2_index
+ i
]);
923 if ((cluster_offset
& QCOW_OFLAG_COPIED
) ||
924 (cluster_offset
& QCOW_OFLAG_COMPRESSED
))
927 j
= count_contiguous_clusters(nb_clusters
- i
, s
->cluster_size
,
928 &l2_table
[l2_index
+ i
], 0);
931 free_any_clusters(bs
, cluster_offset
, j
);
935 if(be64_to_cpu(l2_table
[l2_index
+ i
]))
940 /* allocate a new cluster */
942 cluster_offset
= alloc_clusters(bs
, nb_clusters
* s
->cluster_size
);
944 /* we must initialize the cluster content which won't be
947 nb_available
= nb_clusters
<< (s
->cluster_bits
- 9);
948 if (nb_available
> n_end
)
949 nb_available
= n_end
;
951 /* copy content of unmodified sectors */
953 start_sect
= (offset
& ~(s
->cluster_size
- 1)) >> 9;
955 ret
= copy_sectors(bs
, start_sect
, cluster_offset
, 0, n_start
);
960 if (nb_available
& (s
->cluster_sectors
- 1)) {
961 uint64_t end
= nb_available
& ~(uint64_t)(s
->cluster_sectors
- 1);
962 ret
= copy_sectors(bs
, start_sect
+ end
,
963 cluster_offset
+ (end
<< 9),
970 /* update L2 table */
972 for (i
= 0; i
< nb_clusters
; i
++)
973 l2_table
[l2_index
+ i
] = cpu_to_be64((cluster_offset
+
974 (i
<< s
->cluster_bits
)) |
977 if (bdrv_pwrite(s
->hd
,
978 l2_offset
+ l2_index
* sizeof(uint64_t),
980 nb_clusters
* sizeof(uint64_t)) !=
981 nb_clusters
* sizeof(uint64_t))
985 *num
= nb_available
- n_start
;
987 return cluster_offset
;
990 static int qcow_is_allocated(BlockDriverState
*bs
, int64_t sector_num
,
991 int nb_sectors
, int *pnum
)
993 uint64_t cluster_offset
;
996 cluster_offset
= get_cluster_offset(bs
, sector_num
<< 9, pnum
);
998 return (cluster_offset
!= 0);
1001 static int decompress_buffer(uint8_t *out_buf
, int out_buf_size
,
1002 const uint8_t *buf
, int buf_size
)
1004 z_stream strm1
, *strm
= &strm1
;
1007 memset(strm
, 0, sizeof(*strm
));
1009 strm
->next_in
= (uint8_t *)buf
;
1010 strm
->avail_in
= buf_size
;
1011 strm
->next_out
= out_buf
;
1012 strm
->avail_out
= out_buf_size
;
1014 ret
= inflateInit2(strm
, -12);
1017 ret
= inflate(strm
, Z_FINISH
);
1018 out_len
= strm
->next_out
- out_buf
;
1019 if ((ret
!= Z_STREAM_END
&& ret
!= Z_BUF_ERROR
) ||
1020 out_len
!= out_buf_size
) {
1028 static int decompress_cluster(BDRVQcowState
*s
, uint64_t cluster_offset
)
1030 int ret
, csize
, nb_csectors
, sector_offset
;
1033 coffset
= cluster_offset
& s
->cluster_offset_mask
;
1034 if (s
->cluster_cache_offset
!= coffset
) {
1035 nb_csectors
= ((cluster_offset
>> s
->csize_shift
) & s
->csize_mask
) + 1;
1036 sector_offset
= coffset
& 511;
1037 csize
= nb_csectors
* 512 - sector_offset
;
1038 ret
= bdrv_read(s
->hd
, coffset
>> 9, s
->cluster_data
, nb_csectors
);
1042 if (decompress_buffer(s
->cluster_cache
, s
->cluster_size
,
1043 s
->cluster_data
+ sector_offset
, csize
) < 0) {
1046 s
->cluster_cache_offset
= coffset
;
1051 /* handle reading after the end of the backing file */
1052 static int backing_read1(BlockDriverState
*bs
,
1053 int64_t sector_num
, uint8_t *buf
, int nb_sectors
)
1056 if ((sector_num
+ nb_sectors
) <= bs
->total_sectors
)
1058 if (sector_num
>= bs
->total_sectors
)
1061 n1
= bs
->total_sectors
- sector_num
;
1062 memset(buf
+ n1
* 512, 0, 512 * (nb_sectors
- n1
));
1066 static int qcow_read(BlockDriverState
*bs
, int64_t sector_num
,
1067 uint8_t *buf
, int nb_sectors
)
1069 BDRVQcowState
*s
= bs
->opaque
;
1070 int ret
, index_in_cluster
, n
, n1
;
1071 uint64_t cluster_offset
;
1073 while (nb_sectors
> 0) {
1075 cluster_offset
= get_cluster_offset(bs
, sector_num
<< 9, &n
);
1076 index_in_cluster
= sector_num
& (s
->cluster_sectors
- 1);
1077 if (!cluster_offset
) {
1078 if (bs
->backing_hd
) {
1079 /* read from the base image */
1080 n1
= backing_read1(bs
->backing_hd
, sector_num
, buf
, n
);
1082 ret
= bdrv_read(bs
->backing_hd
, sector_num
, buf
, n1
);
1087 memset(buf
, 0, 512 * n
);
1089 } else if (cluster_offset
& QCOW_OFLAG_COMPRESSED
) {
1090 if (decompress_cluster(s
, cluster_offset
) < 0)
1092 memcpy(buf
, s
->cluster_cache
+ index_in_cluster
* 512, 512 * n
);
1094 ret
= bdrv_pread(s
->hd
, cluster_offset
+ index_in_cluster
* 512, buf
, n
* 512);
1097 if (s
->crypt_method
) {
1098 encrypt_sectors(s
, sector_num
, buf
, buf
, n
, 0,
1099 &s
->aes_decrypt_key
);
1109 static int qcow_write(BlockDriverState
*bs
, int64_t sector_num
,
1110 const uint8_t *buf
, int nb_sectors
)
1112 BDRVQcowState
*s
= bs
->opaque
;
1113 int ret
, index_in_cluster
, n
;
1114 uint64_t cluster_offset
;
1117 while (nb_sectors
> 0) {
1118 index_in_cluster
= sector_num
& (s
->cluster_sectors
- 1);
1119 n_end
= index_in_cluster
+ nb_sectors
;
1120 if (s
->crypt_method
&&
1121 n_end
> QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_sectors
)
1122 n_end
= QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_sectors
;
1123 cluster_offset
= alloc_cluster_offset(bs
, sector_num
<< 9,
1126 if (!cluster_offset
)
1128 if (s
->crypt_method
) {
1129 encrypt_sectors(s
, sector_num
, s
->cluster_data
, buf
, n
, 1,
1130 &s
->aes_encrypt_key
);
1131 ret
= bdrv_pwrite(s
->hd
, cluster_offset
+ index_in_cluster
* 512,
1132 s
->cluster_data
, n
* 512);
1134 ret
= bdrv_pwrite(s
->hd
, cluster_offset
+ index_in_cluster
* 512, buf
, n
* 512);
1142 s
->cluster_cache_offset
= -1; /* disable compressed cache */
1146 typedef struct QCowAIOCB
{
1147 BlockDriverAIOCB common
;
1152 uint64_t cluster_offset
;
1153 uint8_t *cluster_data
;
1154 BlockDriverAIOCB
*hd_aiocb
;
1158 static void qcow_aio_read_cb(void *opaque
, int ret
);
1159 static void qcow_aio_read_bh(void *opaque
)
1161 QCowAIOCB
*acb
= opaque
;
1162 qemu_bh_delete(acb
->bh
);
1164 qcow_aio_read_cb(opaque
, 0);
1167 static int qcow_schedule_bh(QEMUBHFunc
*cb
, QCowAIOCB
*acb
)
1172 acb
->bh
= qemu_bh_new(cb
, acb
);
1176 qemu_bh_schedule(acb
->bh
);
1181 static void qcow_aio_read_cb(void *opaque
, int ret
)
1183 QCowAIOCB
*acb
= opaque
;
1184 BlockDriverState
*bs
= acb
->common
.bs
;
1185 BDRVQcowState
*s
= bs
->opaque
;
1186 int index_in_cluster
, n1
;
1188 acb
->hd_aiocb
= NULL
;
1191 acb
->common
.cb(acb
->common
.opaque
, ret
);
1192 qemu_aio_release(acb
);
1196 /* post process the read buffer */
1197 if (!acb
->cluster_offset
) {
1199 } else if (acb
->cluster_offset
& QCOW_OFLAG_COMPRESSED
) {
1202 if (s
->crypt_method
) {
1203 encrypt_sectors(s
, acb
->sector_num
, acb
->buf
, acb
->buf
,
1205 &s
->aes_decrypt_key
);
1209 acb
->nb_sectors
-= acb
->n
;
1210 acb
->sector_num
+= acb
->n
;
1211 acb
->buf
+= acb
->n
* 512;
1213 if (acb
->nb_sectors
== 0) {
1214 /* request completed */
1215 acb
->common
.cb(acb
->common
.opaque
, 0);
1216 qemu_aio_release(acb
);
1220 /* prepare next AIO request */
1221 acb
->n
= acb
->nb_sectors
;
1222 acb
->cluster_offset
= get_cluster_offset(bs
, acb
->sector_num
<< 9, &acb
->n
);
1223 index_in_cluster
= acb
->sector_num
& (s
->cluster_sectors
- 1);
1225 if (!acb
->cluster_offset
) {
1226 if (bs
->backing_hd
) {
1227 /* read from the base image */
1228 n1
= backing_read1(bs
->backing_hd
, acb
->sector_num
,
1231 acb
->hd_aiocb
= bdrv_aio_read(bs
->backing_hd
, acb
->sector_num
,
1232 acb
->buf
, acb
->n
, qcow_aio_read_cb
, acb
);
1233 if (acb
->hd_aiocb
== NULL
)
1236 ret
= qcow_schedule_bh(qcow_aio_read_bh
, acb
);
1241 /* Note: in this case, no need to wait */
1242 memset(acb
->buf
, 0, 512 * acb
->n
);
1243 ret
= qcow_schedule_bh(qcow_aio_read_bh
, acb
);
1247 } else if (acb
->cluster_offset
& QCOW_OFLAG_COMPRESSED
) {
1248 /* add AIO support for compressed blocks ? */
1249 if (decompress_cluster(s
, acb
->cluster_offset
) < 0)
1252 s
->cluster_cache
+ index_in_cluster
* 512, 512 * acb
->n
);
1253 ret
= qcow_schedule_bh(qcow_aio_read_bh
, acb
);
1257 if ((acb
->cluster_offset
& 511) != 0) {
1261 acb
->hd_aiocb
= bdrv_aio_read(s
->hd
,
1262 (acb
->cluster_offset
>> 9) + index_in_cluster
,
1263 acb
->buf
, acb
->n
, qcow_aio_read_cb
, acb
);
1264 if (acb
->hd_aiocb
== NULL
)
1269 static QCowAIOCB
*qcow_aio_setup(BlockDriverState
*bs
,
1270 int64_t sector_num
, uint8_t *buf
, int nb_sectors
,
1271 BlockDriverCompletionFunc
*cb
, void *opaque
)
1275 acb
= qemu_aio_get(bs
, cb
, opaque
);
1278 acb
->hd_aiocb
= NULL
;
1279 acb
->sector_num
= sector_num
;
1281 acb
->nb_sectors
= nb_sectors
;
1283 acb
->cluster_offset
= 0;
1287 static BlockDriverAIOCB
*qcow_aio_read(BlockDriverState
*bs
,
1288 int64_t sector_num
, uint8_t *buf
, int nb_sectors
,
1289 BlockDriverCompletionFunc
*cb
, void *opaque
)
1293 acb
= qcow_aio_setup(bs
, sector_num
, buf
, nb_sectors
, cb
, opaque
);
1297 qcow_aio_read_cb(acb
, 0);
1298 return &acb
->common
;
1301 static void qcow_aio_write_cb(void *opaque
, int ret
)
1303 QCowAIOCB
*acb
= opaque
;
1304 BlockDriverState
*bs
= acb
->common
.bs
;
1305 BDRVQcowState
*s
= bs
->opaque
;
1306 int index_in_cluster
;
1307 uint64_t cluster_offset
;
1308 const uint8_t *src_buf
;
1311 acb
->hd_aiocb
= NULL
;
1315 acb
->common
.cb(acb
->common
.opaque
, ret
);
1316 qemu_aio_release(acb
);
1320 acb
->nb_sectors
-= acb
->n
;
1321 acb
->sector_num
+= acb
->n
;
1322 acb
->buf
+= acb
->n
* 512;
1324 if (acb
->nb_sectors
== 0) {
1325 /* request completed */
1326 acb
->common
.cb(acb
->common
.opaque
, 0);
1327 qemu_aio_release(acb
);
1331 index_in_cluster
= acb
->sector_num
& (s
->cluster_sectors
- 1);
1332 n_end
= index_in_cluster
+ acb
->nb_sectors
;
1333 if (s
->crypt_method
&&
1334 n_end
> QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_sectors
)
1335 n_end
= QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_sectors
;
1337 cluster_offset
= alloc_cluster_offset(bs
, acb
->sector_num
<< 9,
1340 if (!cluster_offset
|| (cluster_offset
& 511) != 0) {
1344 if (s
->crypt_method
) {
1345 if (!acb
->cluster_data
) {
1346 acb
->cluster_data
= qemu_mallocz(QCOW_MAX_CRYPT_CLUSTERS
*
1348 if (!acb
->cluster_data
) {
1353 encrypt_sectors(s
, acb
->sector_num
, acb
->cluster_data
, acb
->buf
,
1354 acb
->n
, 1, &s
->aes_encrypt_key
);
1355 src_buf
= acb
->cluster_data
;
1359 acb
->hd_aiocb
= bdrv_aio_write(s
->hd
,
1360 (cluster_offset
>> 9) + index_in_cluster
,
1362 qcow_aio_write_cb
, acb
);
1363 if (acb
->hd_aiocb
== NULL
)
1367 static BlockDriverAIOCB
*qcow_aio_write(BlockDriverState
*bs
,
1368 int64_t sector_num
, const uint8_t *buf
, int nb_sectors
,
1369 BlockDriverCompletionFunc
*cb
, void *opaque
)
1371 BDRVQcowState
*s
= bs
->opaque
;
1374 s
->cluster_cache_offset
= -1; /* disable compressed cache */
1376 acb
= qcow_aio_setup(bs
, sector_num
, (uint8_t*)buf
, nb_sectors
, cb
, opaque
);
1380 qcow_aio_write_cb(acb
, 0);
1381 return &acb
->common
;
1384 static void qcow_aio_cancel(BlockDriverAIOCB
*blockacb
)
1386 QCowAIOCB
*acb
= (QCowAIOCB
*)blockacb
;
1388 bdrv_aio_cancel(acb
->hd_aiocb
);
1389 qemu_aio_release(acb
);
1392 static void qcow_close(BlockDriverState
*bs
)
1394 BDRVQcowState
*s
= bs
->opaque
;
1395 qemu_free(s
->l1_table
);
1396 qemu_free(s
->l2_cache
);
1397 qemu_free(s
->cluster_cache
);
1398 qemu_free(s
->cluster_data
);
1403 /* XXX: use std qcow open function ? */
1404 typedef struct QCowCreateState
{
1407 uint16_t *refcount_block
;
1408 uint64_t *refcount_table
;
1409 int64_t l1_table_offset
;
1410 int64_t refcount_table_offset
;
1411 int64_t refcount_block_offset
;
1414 static void create_refcount_update(QCowCreateState
*s
,
1415 int64_t offset
, int64_t size
)
1418 int64_t start
, last
, cluster_offset
;
1421 start
= offset
& ~(s
->cluster_size
- 1);
1422 last
= (offset
+ size
- 1) & ~(s
->cluster_size
- 1);
1423 for(cluster_offset
= start
; cluster_offset
<= last
;
1424 cluster_offset
+= s
->cluster_size
) {
1425 p
= &s
->refcount_block
[cluster_offset
>> s
->cluster_bits
];
1426 refcount
= be16_to_cpu(*p
);
1428 *p
= cpu_to_be16(refcount
);
1432 static int qcow_create(const char *filename
, int64_t total_size
,
1433 const char *backing_file
, int flags
)
1435 int fd
, header_size
, backing_filename_len
, l1_size
, i
, shift
, l2_bits
;
1437 uint64_t tmp
, offset
;
1438 QCowCreateState s1
, *s
= &s1
;
1440 memset(s
, 0, sizeof(*s
));
1442 fd
= open(filename
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_BINARY
, 0644);
1445 memset(&header
, 0, sizeof(header
));
1446 header
.magic
= cpu_to_be32(QCOW_MAGIC
);
1447 header
.version
= cpu_to_be32(QCOW_VERSION
);
1448 header
.size
= cpu_to_be64(total_size
* 512);
1449 header_size
= sizeof(header
);
1450 backing_filename_len
= 0;
1452 header
.backing_file_offset
= cpu_to_be64(header_size
);
1453 backing_filename_len
= strlen(backing_file
);
1454 header
.backing_file_size
= cpu_to_be32(backing_filename_len
);
1455 header_size
+= backing_filename_len
;
1457 s
->cluster_bits
= 12; /* 4 KB clusters */
1458 s
->cluster_size
= 1 << s
->cluster_bits
;
1459 header
.cluster_bits
= cpu_to_be32(s
->cluster_bits
);
1460 header_size
= (header_size
+ 7) & ~7;
1461 if (flags
& BLOCK_FLAG_ENCRYPT
) {
1462 header
.crypt_method
= cpu_to_be32(QCOW_CRYPT_AES
);
1464 header
.crypt_method
= cpu_to_be32(QCOW_CRYPT_NONE
);
1466 l2_bits
= s
->cluster_bits
- 3;
1467 shift
= s
->cluster_bits
+ l2_bits
;
1468 l1_size
= (((total_size
* 512) + (1LL << shift
) - 1) >> shift
);
1469 offset
= align_offset(header_size
, s
->cluster_size
);
1470 s
->l1_table_offset
= offset
;
1471 header
.l1_table_offset
= cpu_to_be64(s
->l1_table_offset
);
1472 header
.l1_size
= cpu_to_be32(l1_size
);
1473 offset
+= align_offset(l1_size
* sizeof(uint64_t), s
->cluster_size
);
1475 s
->refcount_table
= qemu_mallocz(s
->cluster_size
);
1476 if (!s
->refcount_table
)
1478 s
->refcount_block
= qemu_mallocz(s
->cluster_size
);
1479 if (!s
->refcount_block
)
1482 s
->refcount_table_offset
= offset
;
1483 header
.refcount_table_offset
= cpu_to_be64(offset
);
1484 header
.refcount_table_clusters
= cpu_to_be32(1);
1485 offset
+= s
->cluster_size
;
1487 s
->refcount_table
[0] = cpu_to_be64(offset
);
1488 s
->refcount_block_offset
= offset
;
1489 offset
+= s
->cluster_size
;
1491 /* update refcounts */
1492 create_refcount_update(s
, 0, header_size
);
1493 create_refcount_update(s
, s
->l1_table_offset
, l1_size
* sizeof(uint64_t));
1494 create_refcount_update(s
, s
->refcount_table_offset
, s
->cluster_size
);
1495 create_refcount_update(s
, s
->refcount_block_offset
, s
->cluster_size
);
1497 /* write all the data */
1498 write(fd
, &header
, sizeof(header
));
1500 write(fd
, backing_file
, backing_filename_len
);
1502 lseek(fd
, s
->l1_table_offset
, SEEK_SET
);
1504 for(i
= 0;i
< l1_size
; i
++) {
1505 write(fd
, &tmp
, sizeof(tmp
));
1507 lseek(fd
, s
->refcount_table_offset
, SEEK_SET
);
1508 write(fd
, s
->refcount_table
, s
->cluster_size
);
1510 lseek(fd
, s
->refcount_block_offset
, SEEK_SET
);
1511 write(fd
, s
->refcount_block
, s
->cluster_size
);
1513 qemu_free(s
->refcount_table
);
1514 qemu_free(s
->refcount_block
);
1518 qemu_free(s
->refcount_table
);
1519 qemu_free(s
->refcount_block
);
1524 static int qcow_make_empty(BlockDriverState
*bs
)
1527 /* XXX: not correct */
1528 BDRVQcowState
*s
= bs
->opaque
;
1529 uint32_t l1_length
= s
->l1_size
* sizeof(uint64_t);
1532 memset(s
->l1_table
, 0, l1_length
);
1533 if (bdrv_pwrite(s
->hd
, s
->l1_table_offset
, s
->l1_table
, l1_length
) < 0)
1535 ret
= bdrv_truncate(s
->hd
, s
->l1_table_offset
+ l1_length
);
1544 /* XXX: put compressed sectors first, then all the cluster aligned
1545 tables to avoid losing bytes in alignment */
1546 static int qcow_write_compressed(BlockDriverState
*bs
, int64_t sector_num
,
1547 const uint8_t *buf
, int nb_sectors
)
1549 BDRVQcowState
*s
= bs
->opaque
;
1553 uint64_t cluster_offset
;
1555 if (nb_sectors
== 0) {
1556 /* align end of file to a sector boundary to ease reading with
1557 sector based I/Os */
1558 cluster_offset
= bdrv_getlength(s
->hd
);
1559 cluster_offset
= (cluster_offset
+ 511) & ~511;
1560 bdrv_truncate(s
->hd
, cluster_offset
);
1564 if (nb_sectors
!= s
->cluster_sectors
)
1567 out_buf
= qemu_malloc(s
->cluster_size
+ (s
->cluster_size
/ 1000) + 128);
1571 /* best compression, small window, no zlib header */
1572 memset(&strm
, 0, sizeof(strm
));
1573 ret
= deflateInit2(&strm
, Z_DEFAULT_COMPRESSION
,
1575 9, Z_DEFAULT_STRATEGY
);
1581 strm
.avail_in
= s
->cluster_size
;
1582 strm
.next_in
= (uint8_t *)buf
;
1583 strm
.avail_out
= s
->cluster_size
;
1584 strm
.next_out
= out_buf
;
1586 ret
= deflate(&strm
, Z_FINISH
);
1587 if (ret
!= Z_STREAM_END
&& ret
!= Z_OK
) {
1592 out_len
= strm
.next_out
- out_buf
;
1596 if (ret
!= Z_STREAM_END
|| out_len
>= s
->cluster_size
) {
1597 /* could not compress: write normal cluster */
1598 qcow_write(bs
, sector_num
, buf
, s
->cluster_sectors
);
1600 cluster_offset
= alloc_compressed_cluster_offset(bs
, sector_num
<< 9,
1602 if (!cluster_offset
)
1604 cluster_offset
&= s
->cluster_offset_mask
;
1605 if (bdrv_pwrite(s
->hd
, cluster_offset
, out_buf
, out_len
) != out_len
) {
1615 static void qcow_flush(BlockDriverState
*bs
)
1617 BDRVQcowState
*s
= bs
->opaque
;
1621 static int qcow_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
1623 BDRVQcowState
*s
= bs
->opaque
;
1624 bdi
->cluster_size
= s
->cluster_size
;
1625 bdi
->vm_state_offset
= (int64_t)s
->l1_vm_state_index
<<
1626 (s
->cluster_bits
+ s
->l2_bits
);
1630 /*********************************************************/
1631 /* snapshot support */
1633 /* update the refcounts of snapshots and the copied flag */
1634 static int update_snapshot_refcount(BlockDriverState
*bs
,
1635 int64_t l1_table_offset
,
1639 BDRVQcowState
*s
= bs
->opaque
;
1640 uint64_t *l1_table
, *l2_table
, l2_offset
, offset
, l1_size2
, l1_allocated
;
1641 int64_t old_offset
, old_l2_offset
;
1642 int l2_size
, i
, j
, l1_modified
, l2_modified
, nb_csectors
, refcount
;
1648 l1_size2
= l1_size
* sizeof(uint64_t);
1650 if (l1_table_offset
!= s
->l1_table_offset
) {
1651 l1_table
= qemu_malloc(l1_size2
);
1655 if (bdrv_pread(s
->hd
, l1_table_offset
,
1656 l1_table
, l1_size2
) != l1_size2
)
1658 for(i
= 0;i
< l1_size
; i
++)
1659 be64_to_cpus(&l1_table
[i
]);
1661 assert(l1_size
== s
->l1_size
);
1662 l1_table
= s
->l1_table
;
1666 l2_size
= s
->l2_size
* sizeof(uint64_t);
1667 l2_table
= qemu_malloc(l2_size
);
1671 for(i
= 0; i
< l1_size
; i
++) {
1672 l2_offset
= l1_table
[i
];
1674 old_l2_offset
= l2_offset
;
1675 l2_offset
&= ~QCOW_OFLAG_COPIED
;
1677 if (bdrv_pread(s
->hd
, l2_offset
, l2_table
, l2_size
) != l2_size
)
1679 for(j
= 0; j
< s
->l2_size
; j
++) {
1680 offset
= be64_to_cpu(l2_table
[j
]);
1682 old_offset
= offset
;
1683 offset
&= ~QCOW_OFLAG_COPIED
;
1684 if (offset
& QCOW_OFLAG_COMPRESSED
) {
1685 nb_csectors
= ((offset
>> s
->csize_shift
) &
1688 update_refcount(bs
, (offset
& s
->cluster_offset_mask
) & ~511,
1689 nb_csectors
* 512, addend
);
1690 /* compressed clusters are never modified */
1694 refcount
= update_cluster_refcount(bs
, offset
>> s
->cluster_bits
, addend
);
1696 refcount
= get_refcount(bs
, offset
>> s
->cluster_bits
);
1700 if (refcount
== 1) {
1701 offset
|= QCOW_OFLAG_COPIED
;
1703 if (offset
!= old_offset
) {
1704 l2_table
[j
] = cpu_to_be64(offset
);
1710 if (bdrv_pwrite(s
->hd
,
1711 l2_offset
, l2_table
, l2_size
) != l2_size
)
1716 refcount
= update_cluster_refcount(bs
, l2_offset
>> s
->cluster_bits
, addend
);
1718 refcount
= get_refcount(bs
, l2_offset
>> s
->cluster_bits
);
1720 if (refcount
== 1) {
1721 l2_offset
|= QCOW_OFLAG_COPIED
;
1723 if (l2_offset
!= old_l2_offset
) {
1724 l1_table
[i
] = l2_offset
;
1730 for(i
= 0; i
< l1_size
; i
++)
1731 cpu_to_be64s(&l1_table
[i
]);
1732 if (bdrv_pwrite(s
->hd
, l1_table_offset
, l1_table
,
1733 l1_size2
) != l1_size2
)
1735 for(i
= 0; i
< l1_size
; i
++)
1736 be64_to_cpus(&l1_table
[i
]);
1739 qemu_free(l1_table
);
1740 qemu_free(l2_table
);
1744 qemu_free(l1_table
);
1745 qemu_free(l2_table
);
1749 static void qcow_free_snapshots(BlockDriverState
*bs
)
1751 BDRVQcowState
*s
= bs
->opaque
;
1754 for(i
= 0; i
< s
->nb_snapshots
; i
++) {
1755 qemu_free(s
->snapshots
[i
].name
);
1756 qemu_free(s
->snapshots
[i
].id_str
);
1758 qemu_free(s
->snapshots
);
1759 s
->snapshots
= NULL
;
1760 s
->nb_snapshots
= 0;
1763 static int qcow_read_snapshots(BlockDriverState
*bs
)
1765 BDRVQcowState
*s
= bs
->opaque
;
1766 QCowSnapshotHeader h
;
1768 int i
, id_str_size
, name_size
;
1770 uint32_t extra_data_size
;
1772 offset
= s
->snapshots_offset
;
1773 s
->snapshots
= qemu_mallocz(s
->nb_snapshots
* sizeof(QCowSnapshot
));
1776 for(i
= 0; i
< s
->nb_snapshots
; i
++) {
1777 offset
= align_offset(offset
, 8);
1778 if (bdrv_pread(s
->hd
, offset
, &h
, sizeof(h
)) != sizeof(h
))
1780 offset
+= sizeof(h
);
1781 sn
= s
->snapshots
+ i
;
1782 sn
->l1_table_offset
= be64_to_cpu(h
.l1_table_offset
);
1783 sn
->l1_size
= be32_to_cpu(h
.l1_size
);
1784 sn
->vm_state_size
= be32_to_cpu(h
.vm_state_size
);
1785 sn
->date_sec
= be32_to_cpu(h
.date_sec
);
1786 sn
->date_nsec
= be32_to_cpu(h
.date_nsec
);
1787 sn
->vm_clock_nsec
= be64_to_cpu(h
.vm_clock_nsec
);
1788 extra_data_size
= be32_to_cpu(h
.extra_data_size
);
1790 id_str_size
= be16_to_cpu(h
.id_str_size
);
1791 name_size
= be16_to_cpu(h
.name_size
);
1793 offset
+= extra_data_size
;
1795 sn
->id_str
= qemu_malloc(id_str_size
+ 1);
1798 if (bdrv_pread(s
->hd
, offset
, sn
->id_str
, id_str_size
) != id_str_size
)
1800 offset
+= id_str_size
;
1801 sn
->id_str
[id_str_size
] = '\0';
1803 sn
->name
= qemu_malloc(name_size
+ 1);
1806 if (bdrv_pread(s
->hd
, offset
, sn
->name
, name_size
) != name_size
)
1808 offset
+= name_size
;
1809 sn
->name
[name_size
] = '\0';
1811 s
->snapshots_size
= offset
- s
->snapshots_offset
;
1814 qcow_free_snapshots(bs
);
1818 /* add at the end of the file a new list of snapshots */
1819 static int qcow_write_snapshots(BlockDriverState
*bs
)
1821 BDRVQcowState
*s
= bs
->opaque
;
1823 QCowSnapshotHeader h
;
1824 int i
, name_size
, id_str_size
, snapshots_size
;
1827 int64_t offset
, snapshots_offset
;
1829 /* compute the size of the snapshots */
1831 for(i
= 0; i
< s
->nb_snapshots
; i
++) {
1832 sn
= s
->snapshots
+ i
;
1833 offset
= align_offset(offset
, 8);
1834 offset
+= sizeof(h
);
1835 offset
+= strlen(sn
->id_str
);
1836 offset
+= strlen(sn
->name
);
1838 snapshots_size
= offset
;
1840 snapshots_offset
= alloc_clusters(bs
, snapshots_size
);
1841 offset
= snapshots_offset
;
1843 for(i
= 0; i
< s
->nb_snapshots
; i
++) {
1844 sn
= s
->snapshots
+ i
;
1845 memset(&h
, 0, sizeof(h
));
1846 h
.l1_table_offset
= cpu_to_be64(sn
->l1_table_offset
);
1847 h
.l1_size
= cpu_to_be32(sn
->l1_size
);
1848 h
.vm_state_size
= cpu_to_be32(sn
->vm_state_size
);
1849 h
.date_sec
= cpu_to_be32(sn
->date_sec
);
1850 h
.date_nsec
= cpu_to_be32(sn
->date_nsec
);
1851 h
.vm_clock_nsec
= cpu_to_be64(sn
->vm_clock_nsec
);
1853 id_str_size
= strlen(sn
->id_str
);
1854 name_size
= strlen(sn
->name
);
1855 h
.id_str_size
= cpu_to_be16(id_str_size
);
1856 h
.name_size
= cpu_to_be16(name_size
);
1857 offset
= align_offset(offset
, 8);
1858 if (bdrv_pwrite(s
->hd
, offset
, &h
, sizeof(h
)) != sizeof(h
))
1860 offset
+= sizeof(h
);
1861 if (bdrv_pwrite(s
->hd
, offset
, sn
->id_str
, id_str_size
) != id_str_size
)
1863 offset
+= id_str_size
;
1864 if (bdrv_pwrite(s
->hd
, offset
, sn
->name
, name_size
) != name_size
)
1866 offset
+= name_size
;
1869 /* update the various header fields */
1870 data64
= cpu_to_be64(snapshots_offset
);
1871 if (bdrv_pwrite(s
->hd
, offsetof(QCowHeader
, snapshots_offset
),
1872 &data64
, sizeof(data64
)) != sizeof(data64
))
1874 data32
= cpu_to_be32(s
->nb_snapshots
);
1875 if (bdrv_pwrite(s
->hd
, offsetof(QCowHeader
, nb_snapshots
),
1876 &data32
, sizeof(data32
)) != sizeof(data32
))
1879 /* free the old snapshot table */
1880 free_clusters(bs
, s
->snapshots_offset
, s
->snapshots_size
);
1881 s
->snapshots_offset
= snapshots_offset
;
1882 s
->snapshots_size
= snapshots_size
;
1888 static void find_new_snapshot_id(BlockDriverState
*bs
,
1889 char *id_str
, int id_str_size
)
1891 BDRVQcowState
*s
= bs
->opaque
;
1893 int i
, id
, id_max
= 0;
1895 for(i
= 0; i
< s
->nb_snapshots
; i
++) {
1896 sn
= s
->snapshots
+ i
;
1897 id
= strtoul(sn
->id_str
, NULL
, 10);
1901 snprintf(id_str
, id_str_size
, "%d", id_max
+ 1);
1904 static int find_snapshot_by_id(BlockDriverState
*bs
, const char *id_str
)
1906 BDRVQcowState
*s
= bs
->opaque
;
1909 for(i
= 0; i
< s
->nb_snapshots
; i
++) {
1910 if (!strcmp(s
->snapshots
[i
].id_str
, id_str
))
1916 static int find_snapshot_by_id_or_name(BlockDriverState
*bs
, const char *name
)
1918 BDRVQcowState
*s
= bs
->opaque
;
1921 ret
= find_snapshot_by_id(bs
, name
);
1924 for(i
= 0; i
< s
->nb_snapshots
; i
++) {
1925 if (!strcmp(s
->snapshots
[i
].name
, name
))
1931 /* if no id is provided, a new one is constructed */
1932 static int qcow_snapshot_create(BlockDriverState
*bs
,
1933 QEMUSnapshotInfo
*sn_info
)
1935 BDRVQcowState
*s
= bs
->opaque
;
1936 QCowSnapshot
*snapshots1
, sn1
, *sn
= &sn1
;
1938 uint64_t *l1_table
= NULL
;
1940 memset(sn
, 0, sizeof(*sn
));
1942 if (sn_info
->id_str
[0] == '\0') {
1943 /* compute a new id */
1944 find_new_snapshot_id(bs
, sn_info
->id_str
, sizeof(sn_info
->id_str
));
1947 /* check that the ID is unique */
1948 if (find_snapshot_by_id(bs
, sn_info
->id_str
) >= 0)
1951 sn
->id_str
= qemu_strdup(sn_info
->id_str
);
1954 sn
->name
= qemu_strdup(sn_info
->name
);
1957 sn
->vm_state_size
= sn_info
->vm_state_size
;
1958 sn
->date_sec
= sn_info
->date_sec
;
1959 sn
->date_nsec
= sn_info
->date_nsec
;
1960 sn
->vm_clock_nsec
= sn_info
->vm_clock_nsec
;
1962 ret
= update_snapshot_refcount(bs
, s
->l1_table_offset
, s
->l1_size
, 1);
1966 /* create the L1 table of the snapshot */
1967 sn
->l1_table_offset
= alloc_clusters(bs
, s
->l1_size
* sizeof(uint64_t));
1968 sn
->l1_size
= s
->l1_size
;
1970 l1_table
= qemu_malloc(s
->l1_size
* sizeof(uint64_t));
1973 for(i
= 0; i
< s
->l1_size
; i
++) {
1974 l1_table
[i
] = cpu_to_be64(s
->l1_table
[i
]);
1976 if (bdrv_pwrite(s
->hd
, sn
->l1_table_offset
,
1977 l1_table
, s
->l1_size
* sizeof(uint64_t)) !=
1978 (s
->l1_size
* sizeof(uint64_t)))
1980 qemu_free(l1_table
);
1983 snapshots1
= qemu_malloc((s
->nb_snapshots
+ 1) * sizeof(QCowSnapshot
));
1986 memcpy(snapshots1
, s
->snapshots
, s
->nb_snapshots
* sizeof(QCowSnapshot
));
1987 s
->snapshots
= snapshots1
;
1988 s
->snapshots
[s
->nb_snapshots
++] = *sn
;
1990 if (qcow_write_snapshots(bs
) < 0)
1993 check_refcounts(bs
);
1997 qemu_free(sn
->name
);
1998 qemu_free(l1_table
);
2002 /* copy the snapshot 'snapshot_name' into the current disk image */
2003 static int qcow_snapshot_goto(BlockDriverState
*bs
,
2004 const char *snapshot_id
)
2006 BDRVQcowState
*s
= bs
->opaque
;
2008 int i
, snapshot_index
, l1_size2
;
2010 snapshot_index
= find_snapshot_by_id_or_name(bs
, snapshot_id
);
2011 if (snapshot_index
< 0)
2013 sn
= &s
->snapshots
[snapshot_index
];
2015 if (update_snapshot_refcount(bs
, s
->l1_table_offset
, s
->l1_size
, -1) < 0)
2018 if (grow_l1_table(bs
, sn
->l1_size
) < 0)
2021 s
->l1_size
= sn
->l1_size
;
2022 l1_size2
= s
->l1_size
* sizeof(uint64_t);
2023 /* copy the snapshot l1 table to the current l1 table */
2024 if (bdrv_pread(s
->hd
, sn
->l1_table_offset
,
2025 s
->l1_table
, l1_size2
) != l1_size2
)
2027 if (bdrv_pwrite(s
->hd
, s
->l1_table_offset
,
2028 s
->l1_table
, l1_size2
) != l1_size2
)
2030 for(i
= 0;i
< s
->l1_size
; i
++) {
2031 be64_to_cpus(&s
->l1_table
[i
]);
2034 if (update_snapshot_refcount(bs
, s
->l1_table_offset
, s
->l1_size
, 1) < 0)
2038 check_refcounts(bs
);
2045 static int qcow_snapshot_delete(BlockDriverState
*bs
, const char *snapshot_id
)
2047 BDRVQcowState
*s
= bs
->opaque
;
2049 int snapshot_index
, ret
;
2051 snapshot_index
= find_snapshot_by_id_or_name(bs
, snapshot_id
);
2052 if (snapshot_index
< 0)
2054 sn
= &s
->snapshots
[snapshot_index
];
2056 ret
= update_snapshot_refcount(bs
, sn
->l1_table_offset
, sn
->l1_size
, -1);
2059 /* must update the copied flag on the current cluster offsets */
2060 ret
= update_snapshot_refcount(bs
, s
->l1_table_offset
, s
->l1_size
, 0);
2063 free_clusters(bs
, sn
->l1_table_offset
, sn
->l1_size
* sizeof(uint64_t));
2065 qemu_free(sn
->id_str
);
2066 qemu_free(sn
->name
);
2067 memmove(sn
, sn
+ 1, (s
->nb_snapshots
- snapshot_index
- 1) * sizeof(*sn
));
2069 ret
= qcow_write_snapshots(bs
);
2071 /* XXX: restore snapshot if error ? */
2075 check_refcounts(bs
);
2080 static int qcow_snapshot_list(BlockDriverState
*bs
,
2081 QEMUSnapshotInfo
**psn_tab
)
2083 BDRVQcowState
*s
= bs
->opaque
;
2084 QEMUSnapshotInfo
*sn_tab
, *sn_info
;
2088 sn_tab
= qemu_mallocz(s
->nb_snapshots
* sizeof(QEMUSnapshotInfo
));
2091 for(i
= 0; i
< s
->nb_snapshots
; i
++) {
2092 sn_info
= sn_tab
+ i
;
2093 sn
= s
->snapshots
+ i
;
2094 pstrcpy(sn_info
->id_str
, sizeof(sn_info
->id_str
),
2096 pstrcpy(sn_info
->name
, sizeof(sn_info
->name
),
2098 sn_info
->vm_state_size
= sn
->vm_state_size
;
2099 sn_info
->date_sec
= sn
->date_sec
;
2100 sn_info
->date_nsec
= sn
->date_nsec
;
2101 sn_info
->vm_clock_nsec
= sn
->vm_clock_nsec
;
2104 return s
->nb_snapshots
;
2111 /*********************************************************/
2112 /* refcount handling */
2114 static int refcount_init(BlockDriverState
*bs
)
2116 BDRVQcowState
*s
= bs
->opaque
;
2117 int ret
, refcount_table_size2
, i
;
2119 s
->refcount_block_cache
= qemu_malloc(s
->cluster_size
);
2120 if (!s
->refcount_block_cache
)
2122 refcount_table_size2
= s
->refcount_table_size
* sizeof(uint64_t);
2123 s
->refcount_table
= qemu_malloc(refcount_table_size2
);
2124 if (!s
->refcount_table
)
2126 if (s
->refcount_table_size
> 0) {
2127 ret
= bdrv_pread(s
->hd
, s
->refcount_table_offset
,
2128 s
->refcount_table
, refcount_table_size2
);
2129 if (ret
!= refcount_table_size2
)
2131 for(i
= 0; i
< s
->refcount_table_size
; i
++)
2132 be64_to_cpus(&s
->refcount_table
[i
]);
2139 static void refcount_close(BlockDriverState
*bs
)
2141 BDRVQcowState
*s
= bs
->opaque
;
2142 qemu_free(s
->refcount_block_cache
);
2143 qemu_free(s
->refcount_table
);
2147 static int load_refcount_block(BlockDriverState
*bs
,
2148 int64_t refcount_block_offset
)
2150 BDRVQcowState
*s
= bs
->opaque
;
2152 ret
= bdrv_pread(s
->hd
, refcount_block_offset
, s
->refcount_block_cache
,
2154 if (ret
!= s
->cluster_size
)
2156 s
->refcount_block_cache_offset
= refcount_block_offset
;
2160 static int get_refcount(BlockDriverState
*bs
, int64_t cluster_index
)
2162 BDRVQcowState
*s
= bs
->opaque
;
2163 int refcount_table_index
, block_index
;
2164 int64_t refcount_block_offset
;
2166 refcount_table_index
= cluster_index
>> (s
->cluster_bits
- REFCOUNT_SHIFT
);
2167 if (refcount_table_index
>= s
->refcount_table_size
)
2169 refcount_block_offset
= s
->refcount_table
[refcount_table_index
];
2170 if (!refcount_block_offset
)
2172 if (refcount_block_offset
!= s
->refcount_block_cache_offset
) {
2173 /* better than nothing: return allocated if read error */
2174 if (load_refcount_block(bs
, refcount_block_offset
) < 0)
2177 block_index
= cluster_index
&
2178 ((1 << (s
->cluster_bits
- REFCOUNT_SHIFT
)) - 1);
2179 return be16_to_cpu(s
->refcount_block_cache
[block_index
]);
2182 /* return < 0 if error */
2183 static int64_t alloc_clusters_noref(BlockDriverState
*bs
, int64_t size
)
2185 BDRVQcowState
*s
= bs
->opaque
;
2188 nb_clusters
= size_to_clusters(s
, size
);
2190 for(i
= 0; i
< nb_clusters
; i
++) {
2191 int64_t i
= s
->free_cluster_index
++;
2192 if (get_refcount(bs
, i
) != 0)
2196 printf("alloc_clusters: size=%lld -> %lld\n",
2198 (s
->free_cluster_index
- nb_clusters
) << s
->cluster_bits
);
2200 return (s
->free_cluster_index
- nb_clusters
) << s
->cluster_bits
;
2203 static int64_t alloc_clusters(BlockDriverState
*bs
, int64_t size
)
2207 offset
= alloc_clusters_noref(bs
, size
);
2208 update_refcount(bs
, offset
, size
, 1);
2212 /* only used to allocate compressed sectors. We try to allocate
2213 contiguous sectors. size must be <= cluster_size */
2214 static int64_t alloc_bytes(BlockDriverState
*bs
, int size
)
2216 BDRVQcowState
*s
= bs
->opaque
;
2217 int64_t offset
, cluster_offset
;
2218 int free_in_cluster
;
2220 assert(size
> 0 && size
<= s
->cluster_size
);
2221 if (s
->free_byte_offset
== 0) {
2222 s
->free_byte_offset
= alloc_clusters(bs
, s
->cluster_size
);
2225 free_in_cluster
= s
->cluster_size
-
2226 (s
->free_byte_offset
& (s
->cluster_size
- 1));
2227 if (size
<= free_in_cluster
) {
2228 /* enough space in current cluster */
2229 offset
= s
->free_byte_offset
;
2230 s
->free_byte_offset
+= size
;
2231 free_in_cluster
-= size
;
2232 if (free_in_cluster
== 0)
2233 s
->free_byte_offset
= 0;
2234 if ((offset
& (s
->cluster_size
- 1)) != 0)
2235 update_cluster_refcount(bs
, offset
>> s
->cluster_bits
, 1);
2237 offset
= alloc_clusters(bs
, s
->cluster_size
);
2238 cluster_offset
= s
->free_byte_offset
& ~(s
->cluster_size
- 1);
2239 if ((cluster_offset
+ s
->cluster_size
) == offset
) {
2240 /* we are lucky: contiguous data */
2241 offset
= s
->free_byte_offset
;
2242 update_cluster_refcount(bs
, offset
>> s
->cluster_bits
, 1);
2243 s
->free_byte_offset
+= size
;
2245 s
->free_byte_offset
= offset
;
2252 static void free_clusters(BlockDriverState
*bs
,
2253 int64_t offset
, int64_t size
)
2255 update_refcount(bs
, offset
, size
, -1);
2258 static int grow_refcount_table(BlockDriverState
*bs
, int min_size
)
2260 BDRVQcowState
*s
= bs
->opaque
;
2261 int new_table_size
, new_table_size2
, refcount_table_clusters
, i
, ret
;
2262 uint64_t *new_table
;
2263 int64_t table_offset
;
2266 int64_t old_table_offset
;
2268 if (min_size
<= s
->refcount_table_size
)
2270 /* compute new table size */
2271 refcount_table_clusters
= s
->refcount_table_size
>> (s
->cluster_bits
- 3);
2273 if (refcount_table_clusters
== 0) {
2274 refcount_table_clusters
= 1;
2276 refcount_table_clusters
= (refcount_table_clusters
* 3 + 1) / 2;
2278 new_table_size
= refcount_table_clusters
<< (s
->cluster_bits
- 3);
2279 if (min_size
<= new_table_size
)
2283 printf("grow_refcount_table from %d to %d\n",
2284 s
->refcount_table_size
,
2287 new_table_size2
= new_table_size
* sizeof(uint64_t);
2288 new_table
= qemu_mallocz(new_table_size2
);
2291 memcpy(new_table
, s
->refcount_table
,
2292 s
->refcount_table_size
* sizeof(uint64_t));
2293 for(i
= 0; i
< s
->refcount_table_size
; i
++)
2294 cpu_to_be64s(&new_table
[i
]);
2295 /* Note: we cannot update the refcount now to avoid recursion */
2296 table_offset
= alloc_clusters_noref(bs
, new_table_size2
);
2297 ret
= bdrv_pwrite(s
->hd
, table_offset
, new_table
, new_table_size2
);
2298 if (ret
!= new_table_size2
)
2300 for(i
= 0; i
< s
->refcount_table_size
; i
++)
2301 be64_to_cpus(&new_table
[i
]);
2303 cpu_to_be64w((uint64_t*)data
, table_offset
);
2304 cpu_to_be32w((uint32_t*)(data
+ 8), refcount_table_clusters
);
2305 if (bdrv_pwrite(s
->hd
, offsetof(QCowHeader
, refcount_table_offset
),
2306 data
, sizeof(data
)) != sizeof(data
))
2308 qemu_free(s
->refcount_table
);
2309 old_table_offset
= s
->refcount_table_offset
;
2310 old_table_size
= s
->refcount_table_size
;
2311 s
->refcount_table
= new_table
;
2312 s
->refcount_table_size
= new_table_size
;
2313 s
->refcount_table_offset
= table_offset
;
2315 update_refcount(bs
, table_offset
, new_table_size2
, 1);
2316 free_clusters(bs
, old_table_offset
, old_table_size
* sizeof(uint64_t));
2319 free_clusters(bs
, table_offset
, new_table_size2
);
2320 qemu_free(new_table
);
2324 /* addend must be 1 or -1 */
2325 /* XXX: cache several refcount block clusters ? */
2326 static int update_cluster_refcount(BlockDriverState
*bs
,
2327 int64_t cluster_index
,
2330 BDRVQcowState
*s
= bs
->opaque
;
2331 int64_t offset
, refcount_block_offset
;
2332 int ret
, refcount_table_index
, block_index
, refcount
;
2335 refcount_table_index
= cluster_index
>> (s
->cluster_bits
- REFCOUNT_SHIFT
);
2336 if (refcount_table_index
>= s
->refcount_table_size
) {
2339 ret
= grow_refcount_table(bs
, refcount_table_index
+ 1);
2343 refcount_block_offset
= s
->refcount_table
[refcount_table_index
];
2344 if (!refcount_block_offset
) {
2347 /* create a new refcount block */
2348 /* Note: we cannot update the refcount now to avoid recursion */
2349 offset
= alloc_clusters_noref(bs
, s
->cluster_size
);
2350 memset(s
->refcount_block_cache
, 0, s
->cluster_size
);
2351 ret
= bdrv_pwrite(s
->hd
, offset
, s
->refcount_block_cache
, s
->cluster_size
);
2352 if (ret
!= s
->cluster_size
)
2354 s
->refcount_table
[refcount_table_index
] = offset
;
2355 data64
= cpu_to_be64(offset
);
2356 ret
= bdrv_pwrite(s
->hd
, s
->refcount_table_offset
+
2357 refcount_table_index
* sizeof(uint64_t),
2358 &data64
, sizeof(data64
));
2359 if (ret
!= sizeof(data64
))
2362 refcount_block_offset
= offset
;
2363 s
->refcount_block_cache_offset
= offset
;
2364 update_refcount(bs
, offset
, s
->cluster_size
, 1);
2366 if (refcount_block_offset
!= s
->refcount_block_cache_offset
) {
2367 if (load_refcount_block(bs
, refcount_block_offset
) < 0)
2371 /* we can update the count and save it */
2372 block_index
= cluster_index
&
2373 ((1 << (s
->cluster_bits
- REFCOUNT_SHIFT
)) - 1);
2374 refcount
= be16_to_cpu(s
->refcount_block_cache
[block_index
]);
2376 if (refcount
< 0 || refcount
> 0xffff)
2378 if (refcount
== 0 && cluster_index
< s
->free_cluster_index
) {
2379 s
->free_cluster_index
= cluster_index
;
2381 s
->refcount_block_cache
[block_index
] = cpu_to_be16(refcount
);
2382 if (bdrv_pwrite(s
->hd
,
2383 refcount_block_offset
+ (block_index
<< REFCOUNT_SHIFT
),
2384 &s
->refcount_block_cache
[block_index
], 2) != 2)
2389 static void update_refcount(BlockDriverState
*bs
,
2390 int64_t offset
, int64_t length
,
2393 BDRVQcowState
*s
= bs
->opaque
;
2394 int64_t start
, last
, cluster_offset
;
2397 printf("update_refcount: offset=%lld size=%lld addend=%d\n",
2398 offset
, length
, addend
);
2402 start
= offset
& ~(s
->cluster_size
- 1);
2403 last
= (offset
+ length
- 1) & ~(s
->cluster_size
- 1);
2404 for(cluster_offset
= start
; cluster_offset
<= last
;
2405 cluster_offset
+= s
->cluster_size
) {
2406 update_cluster_refcount(bs
, cluster_offset
>> s
->cluster_bits
, addend
);
2411 static void inc_refcounts(BlockDriverState
*bs
,
2412 uint16_t *refcount_table
,
2413 int refcount_table_size
,
2414 int64_t offset
, int64_t size
)
2416 BDRVQcowState
*s
= bs
->opaque
;
2417 int64_t start
, last
, cluster_offset
;
2423 start
= offset
& ~(s
->cluster_size
- 1);
2424 last
= (offset
+ size
- 1) & ~(s
->cluster_size
- 1);
2425 for(cluster_offset
= start
; cluster_offset
<= last
;
2426 cluster_offset
+= s
->cluster_size
) {
2427 k
= cluster_offset
>> s
->cluster_bits
;
2428 if (k
< 0 || k
>= refcount_table_size
) {
2429 printf("ERROR: invalid cluster offset=0x%llx\n", cluster_offset
);
2431 if (++refcount_table
[k
] == 0) {
2432 printf("ERROR: overflow cluster offset=0x%llx\n", cluster_offset
);
2438 static int check_refcounts_l1(BlockDriverState
*bs
,
2439 uint16_t *refcount_table
,
2440 int refcount_table_size
,
2441 int64_t l1_table_offset
, int l1_size
,
2444 BDRVQcowState
*s
= bs
->opaque
;
2445 uint64_t *l1_table
, *l2_table
, l2_offset
, offset
, l1_size2
;
2446 int l2_size
, i
, j
, nb_csectors
, refcount
;
2449 l1_size2
= l1_size
* sizeof(uint64_t);
2451 inc_refcounts(bs
, refcount_table
, refcount_table_size
,
2452 l1_table_offset
, l1_size2
);
2454 l1_table
= qemu_malloc(l1_size2
);
2457 if (bdrv_pread(s
->hd
, l1_table_offset
,
2458 l1_table
, l1_size2
) != l1_size2
)
2460 for(i
= 0;i
< l1_size
; i
++)
2461 be64_to_cpus(&l1_table
[i
]);
2463 l2_size
= s
->l2_size
* sizeof(uint64_t);
2464 l2_table
= qemu_malloc(l2_size
);
2467 for(i
= 0; i
< l1_size
; i
++) {
2468 l2_offset
= l1_table
[i
];
2471 refcount
= get_refcount(bs
, (l2_offset
& ~QCOW_OFLAG_COPIED
) >> s
->cluster_bits
);
2472 if ((refcount
== 1) != ((l2_offset
& QCOW_OFLAG_COPIED
) != 0)) {
2473 printf("ERROR OFLAG_COPIED: l2_offset=%llx refcount=%d\n",
2474 l2_offset
, refcount
);
2477 l2_offset
&= ~QCOW_OFLAG_COPIED
;
2478 if (bdrv_pread(s
->hd
, l2_offset
, l2_table
, l2_size
) != l2_size
)
2480 for(j
= 0; j
< s
->l2_size
; j
++) {
2481 offset
= be64_to_cpu(l2_table
[j
]);
2483 if (offset
& QCOW_OFLAG_COMPRESSED
) {
2484 if (offset
& QCOW_OFLAG_COPIED
) {
2485 printf("ERROR: cluster %lld: copied flag must never be set for compressed clusters\n",
2486 offset
>> s
->cluster_bits
);
2487 offset
&= ~QCOW_OFLAG_COPIED
;
2489 nb_csectors
= ((offset
>> s
->csize_shift
) &
2491 offset
&= s
->cluster_offset_mask
;
2492 inc_refcounts(bs
, refcount_table
,
2493 refcount_table_size
,
2494 offset
& ~511, nb_csectors
* 512);
2497 refcount
= get_refcount(bs
, (offset
& ~QCOW_OFLAG_COPIED
) >> s
->cluster_bits
);
2498 if ((refcount
== 1) != ((offset
& QCOW_OFLAG_COPIED
) != 0)) {
2499 printf("ERROR OFLAG_COPIED: offset=%llx refcount=%d\n",
2503 offset
&= ~QCOW_OFLAG_COPIED
;
2504 inc_refcounts(bs
, refcount_table
,
2505 refcount_table_size
,
2506 offset
, s
->cluster_size
);
2510 inc_refcounts(bs
, refcount_table
,
2511 refcount_table_size
,
2516 qemu_free(l1_table
);
2517 qemu_free(l2_table
);
2520 printf("ERROR: I/O error in check_refcounts_l1\n");
2521 qemu_free(l1_table
);
2522 qemu_free(l2_table
);
2526 static void check_refcounts(BlockDriverState
*bs
)
2528 BDRVQcowState
*s
= bs
->opaque
;
2530 int nb_clusters
, refcount1
, refcount2
, i
;
2532 uint16_t *refcount_table
;
2534 size
= bdrv_getlength(s
->hd
);
2535 nb_clusters
= size_to_clusters(s
, size
);
2536 refcount_table
= qemu_mallocz(nb_clusters
* sizeof(uint16_t));
2539 inc_refcounts(bs
, refcount_table
, nb_clusters
,
2540 0, s
->cluster_size
);
2542 check_refcounts_l1(bs
, refcount_table
, nb_clusters
,
2543 s
->l1_table_offset
, s
->l1_size
, 1);
2546 for(i
= 0; i
< s
->nb_snapshots
; i
++) {
2547 sn
= s
->snapshots
+ i
;
2548 check_refcounts_l1(bs
, refcount_table
, nb_clusters
,
2549 sn
->l1_table_offset
, sn
->l1_size
, 0);
2551 inc_refcounts(bs
, refcount_table
, nb_clusters
,
2552 s
->snapshots_offset
, s
->snapshots_size
);
2555 inc_refcounts(bs
, refcount_table
, nb_clusters
,
2556 s
->refcount_table_offset
,
2557 s
->refcount_table_size
* sizeof(uint64_t));
2558 for(i
= 0; i
< s
->refcount_table_size
; i
++) {
2560 offset
= s
->refcount_table
[i
];
2562 inc_refcounts(bs
, refcount_table
, nb_clusters
,
2563 offset
, s
->cluster_size
);
2567 /* compare ref counts */
2568 for(i
= 0; i
< nb_clusters
; i
++) {
2569 refcount1
= get_refcount(bs
, i
);
2570 refcount2
= refcount_table
[i
];
2571 if (refcount1
!= refcount2
)
2572 printf("ERROR cluster %d refcount=%d reference=%d\n",
2573 i
, refcount1
, refcount2
);
2576 qemu_free(refcount_table
);
2580 static void dump_refcounts(BlockDriverState
*bs
)
2582 BDRVQcowState
*s
= bs
->opaque
;
2583 int64_t nb_clusters
, k
, k1
, size
;
2586 size
= bdrv_getlength(s
->hd
);
2587 nb_clusters
= size_to_clusters(s
, size
);
2588 for(k
= 0; k
< nb_clusters
;) {
2590 refcount
= get_refcount(bs
, k
);
2592 while (k
< nb_clusters
&& get_refcount(bs
, k
) == refcount
)
2594 printf("%lld: refcount=%d nb=%lld\n", k
, refcount
, k
- k1
);
2600 BlockDriver bdrv_qcow2
= {
2602 sizeof(BDRVQcowState
),
2614 .bdrv_aio_read
= qcow_aio_read
,
2615 .bdrv_aio_write
= qcow_aio_write
,
2616 .bdrv_aio_cancel
= qcow_aio_cancel
,
2617 .aiocb_size
= sizeof(QCowAIOCB
),
2618 .bdrv_write_compressed
= qcow_write_compressed
,
2620 .bdrv_snapshot_create
= qcow_snapshot_create
,
2621 .bdrv_snapshot_goto
= qcow_snapshot_goto
,
2622 .bdrv_snapshot_delete
= qcow_snapshot_delete
,
2623 .bdrv_snapshot_list
= qcow_snapshot_list
,
2624 .bdrv_get_info
= qcow_get_info
,