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
;
859 typedef struct QCowL2Meta
867 static int alloc_cluster_link_l2(BlockDriverState
*bs
, uint64_t cluster_offset
,
870 BDRVQcowState
*s
= bs
->opaque
;
871 int i
, j
= 0, l2_index
, ret
;
872 uint64_t *old_cluster
, start_sect
, l2_offset
, *l2_table
;
874 if (m
->nb_clusters
== 0)
877 if (!(old_cluster
= qemu_malloc(m
->nb_clusters
* sizeof(uint64_t))))
880 /* copy content of unmodified sectors */
881 start_sect
= (m
->offset
& ~(s
->cluster_size
- 1)) >> 9;
883 ret
= copy_sectors(bs
, start_sect
, cluster_offset
, 0, m
->n_start
);
888 if (m
->nb_available
& (s
->cluster_sectors
- 1)) {
889 uint64_t end
= m
->nb_available
& ~(uint64_t)(s
->cluster_sectors
- 1);
890 ret
= copy_sectors(bs
, start_sect
+ end
, cluster_offset
+ (end
<< 9),
891 m
->nb_available
- end
, s
->cluster_sectors
);
897 /* update L2 table */
898 if (!get_cluster_table(bs
, m
->offset
, &l2_table
, &l2_offset
, &l2_index
))
901 for (i
= 0; i
< m
->nb_clusters
; i
++) {
902 if(l2_table
[l2_index
+ i
] != 0)
903 old_cluster
[j
++] = l2_table
[l2_index
+ i
];
905 l2_table
[l2_index
+ i
] = cpu_to_be64((cluster_offset
+
906 (i
<< s
->cluster_bits
)) | QCOW_OFLAG_COPIED
);
909 if (bdrv_pwrite(s
->hd
, l2_offset
+ l2_index
* sizeof(uint64_t),
910 l2_table
+ l2_index
, m
->nb_clusters
* sizeof(uint64_t)) !=
911 m
->nb_clusters
* sizeof(uint64_t))
914 for (i
= 0; i
< j
; i
++)
915 free_any_clusters(bs
, old_cluster
[i
], 1);
919 qemu_free(old_cluster
);
924 * alloc_cluster_offset
926 * For a given offset of the disk image, return cluster offset in
929 * If the offset is not found, allocate a new cluster.
931 * Return the cluster offset if successful,
932 * Return 0, otherwise.
936 static uint64_t alloc_cluster_offset(BlockDriverState
*bs
,
938 int n_start
, int n_end
,
939 int *num
, QCowL2Meta
*m
)
941 BDRVQcowState
*s
= bs
->opaque
;
943 uint64_t l2_offset
, *l2_table
, cluster_offset
;
944 int nb_clusters
, i
= 0;
946 ret
= get_cluster_table(bs
, offset
, &l2_table
, &l2_offset
, &l2_index
);
950 nb_clusters
= size_to_clusters(s
, n_end
<< 9);
952 nb_clusters
= MIN(nb_clusters
, s
->l2_size
- l2_index
);
954 cluster_offset
= be64_to_cpu(l2_table
[l2_index
]);
956 /* We keep all QCOW_OFLAG_COPIED clusters */
958 if (cluster_offset
& QCOW_OFLAG_COPIED
) {
959 nb_clusters
= count_contiguous_clusters(nb_clusters
, s
->cluster_size
,
960 &l2_table
[l2_index
], 0);
962 cluster_offset
&= ~QCOW_OFLAG_COPIED
;
968 /* for the moment, multiple compressed clusters are not managed */
970 if (cluster_offset
& QCOW_OFLAG_COMPRESSED
)
973 /* how many available clusters ? */
975 while (i
< nb_clusters
) {
976 i
+= count_contiguous_free_clusters(nb_clusters
- i
,
977 &l2_table
[l2_index
+ i
]);
979 cluster_offset
= be64_to_cpu(l2_table
[l2_index
+ i
]);
981 if ((cluster_offset
& QCOW_OFLAG_COPIED
) ||
982 (cluster_offset
& QCOW_OFLAG_COMPRESSED
))
985 i
+= count_contiguous_clusters(nb_clusters
- i
, s
->cluster_size
,
986 &l2_table
[l2_index
+ i
], 0);
988 if(be64_to_cpu(l2_table
[l2_index
+ i
]))
993 /* allocate a new cluster */
995 cluster_offset
= alloc_clusters(bs
, nb_clusters
* s
->cluster_size
);
997 /* save info needed for meta data update */
999 m
->n_start
= n_start
;
1000 m
->nb_clusters
= nb_clusters
;
1003 m
->nb_available
= MIN(nb_clusters
<< (s
->cluster_bits
- 9), n_end
);
1005 *num
= m
->nb_available
- n_start
;
1007 return cluster_offset
;
1010 static int qcow_is_allocated(BlockDriverState
*bs
, int64_t sector_num
,
1011 int nb_sectors
, int *pnum
)
1013 uint64_t cluster_offset
;
1016 cluster_offset
= get_cluster_offset(bs
, sector_num
<< 9, pnum
);
1018 return (cluster_offset
!= 0);
1021 static int decompress_buffer(uint8_t *out_buf
, int out_buf_size
,
1022 const uint8_t *buf
, int buf_size
)
1024 z_stream strm1
, *strm
= &strm1
;
1027 memset(strm
, 0, sizeof(*strm
));
1029 strm
->next_in
= (uint8_t *)buf
;
1030 strm
->avail_in
= buf_size
;
1031 strm
->next_out
= out_buf
;
1032 strm
->avail_out
= out_buf_size
;
1034 ret
= inflateInit2(strm
, -12);
1037 ret
= inflate(strm
, Z_FINISH
);
1038 out_len
= strm
->next_out
- out_buf
;
1039 if ((ret
!= Z_STREAM_END
&& ret
!= Z_BUF_ERROR
) ||
1040 out_len
!= out_buf_size
) {
1048 static int decompress_cluster(BDRVQcowState
*s
, uint64_t cluster_offset
)
1050 int ret
, csize
, nb_csectors
, sector_offset
;
1053 coffset
= cluster_offset
& s
->cluster_offset_mask
;
1054 if (s
->cluster_cache_offset
!= coffset
) {
1055 nb_csectors
= ((cluster_offset
>> s
->csize_shift
) & s
->csize_mask
) + 1;
1056 sector_offset
= coffset
& 511;
1057 csize
= nb_csectors
* 512 - sector_offset
;
1058 ret
= bdrv_read(s
->hd
, coffset
>> 9, s
->cluster_data
, nb_csectors
);
1062 if (decompress_buffer(s
->cluster_cache
, s
->cluster_size
,
1063 s
->cluster_data
+ sector_offset
, csize
) < 0) {
1066 s
->cluster_cache_offset
= coffset
;
1071 /* handle reading after the end of the backing file */
1072 static int backing_read1(BlockDriverState
*bs
,
1073 int64_t sector_num
, uint8_t *buf
, int nb_sectors
)
1076 if ((sector_num
+ nb_sectors
) <= bs
->total_sectors
)
1078 if (sector_num
>= bs
->total_sectors
)
1081 n1
= bs
->total_sectors
- sector_num
;
1082 memset(buf
+ n1
* 512, 0, 512 * (nb_sectors
- n1
));
1086 static int qcow_read(BlockDriverState
*bs
, int64_t sector_num
,
1087 uint8_t *buf
, int nb_sectors
)
1089 BDRVQcowState
*s
= bs
->opaque
;
1090 int ret
, index_in_cluster
, n
, n1
;
1091 uint64_t cluster_offset
;
1093 while (nb_sectors
> 0) {
1095 cluster_offset
= get_cluster_offset(bs
, sector_num
<< 9, &n
);
1096 index_in_cluster
= sector_num
& (s
->cluster_sectors
- 1);
1097 if (!cluster_offset
) {
1098 if (bs
->backing_hd
) {
1099 /* read from the base image */
1100 n1
= backing_read1(bs
->backing_hd
, sector_num
, buf
, n
);
1102 ret
= bdrv_read(bs
->backing_hd
, sector_num
, buf
, n1
);
1107 memset(buf
, 0, 512 * n
);
1109 } else if (cluster_offset
& QCOW_OFLAG_COMPRESSED
) {
1110 if (decompress_cluster(s
, cluster_offset
) < 0)
1112 memcpy(buf
, s
->cluster_cache
+ index_in_cluster
* 512, 512 * n
);
1114 ret
= bdrv_pread(s
->hd
, cluster_offset
+ index_in_cluster
* 512, buf
, n
* 512);
1117 if (s
->crypt_method
) {
1118 encrypt_sectors(s
, sector_num
, buf
, buf
, n
, 0,
1119 &s
->aes_decrypt_key
);
1129 static int qcow_write(BlockDriverState
*bs
, int64_t sector_num
,
1130 const uint8_t *buf
, int nb_sectors
)
1132 BDRVQcowState
*s
= bs
->opaque
;
1133 int ret
, index_in_cluster
, n
;
1134 uint64_t cluster_offset
;
1138 while (nb_sectors
> 0) {
1139 index_in_cluster
= sector_num
& (s
->cluster_sectors
- 1);
1140 n_end
= index_in_cluster
+ nb_sectors
;
1141 if (s
->crypt_method
&&
1142 n_end
> QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_sectors
)
1143 n_end
= QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_sectors
;
1144 cluster_offset
= alloc_cluster_offset(bs
, sector_num
<< 9,
1146 n_end
, &n
, &l2meta
);
1147 if (!cluster_offset
)
1149 if (s
->crypt_method
) {
1150 encrypt_sectors(s
, sector_num
, s
->cluster_data
, buf
, n
, 1,
1151 &s
->aes_encrypt_key
);
1152 ret
= bdrv_pwrite(s
->hd
, cluster_offset
+ index_in_cluster
* 512,
1153 s
->cluster_data
, n
* 512);
1155 ret
= bdrv_pwrite(s
->hd
, cluster_offset
+ index_in_cluster
* 512, buf
, n
* 512);
1157 if (ret
!= n
* 512 || alloc_cluster_link_l2(bs
, cluster_offset
, &l2meta
) < 0) {
1158 free_any_clusters(bs
, cluster_offset
, l2meta
.nb_clusters
);
1165 s
->cluster_cache_offset
= -1; /* disable compressed cache */
1169 typedef struct QCowAIOCB
{
1170 BlockDriverAIOCB common
;
1175 uint64_t cluster_offset
;
1176 uint8_t *cluster_data
;
1177 BlockDriverAIOCB
*hd_aiocb
;
1182 static void qcow_aio_read_cb(void *opaque
, int ret
);
1183 static void qcow_aio_read_bh(void *opaque
)
1185 QCowAIOCB
*acb
= opaque
;
1186 qemu_bh_delete(acb
->bh
);
1188 qcow_aio_read_cb(opaque
, 0);
1191 static int qcow_schedule_bh(QEMUBHFunc
*cb
, QCowAIOCB
*acb
)
1196 acb
->bh
= qemu_bh_new(cb
, acb
);
1200 qemu_bh_schedule(acb
->bh
);
1205 static void qcow_aio_read_cb(void *opaque
, int ret
)
1207 QCowAIOCB
*acb
= opaque
;
1208 BlockDriverState
*bs
= acb
->common
.bs
;
1209 BDRVQcowState
*s
= bs
->opaque
;
1210 int index_in_cluster
, n1
;
1212 acb
->hd_aiocb
= NULL
;
1215 acb
->common
.cb(acb
->common
.opaque
, ret
);
1216 qemu_aio_release(acb
);
1220 /* post process the read buffer */
1221 if (!acb
->cluster_offset
) {
1223 } else if (acb
->cluster_offset
& QCOW_OFLAG_COMPRESSED
) {
1226 if (s
->crypt_method
) {
1227 encrypt_sectors(s
, acb
->sector_num
, acb
->buf
, acb
->buf
,
1229 &s
->aes_decrypt_key
);
1233 acb
->nb_sectors
-= acb
->n
;
1234 acb
->sector_num
+= acb
->n
;
1235 acb
->buf
+= acb
->n
* 512;
1237 if (acb
->nb_sectors
== 0) {
1238 /* request completed */
1239 acb
->common
.cb(acb
->common
.opaque
, 0);
1240 qemu_aio_release(acb
);
1244 /* prepare next AIO request */
1245 acb
->n
= acb
->nb_sectors
;
1246 acb
->cluster_offset
= get_cluster_offset(bs
, acb
->sector_num
<< 9, &acb
->n
);
1247 index_in_cluster
= acb
->sector_num
& (s
->cluster_sectors
- 1);
1249 if (!acb
->cluster_offset
) {
1250 if (bs
->backing_hd
) {
1251 /* read from the base image */
1252 n1
= backing_read1(bs
->backing_hd
, acb
->sector_num
,
1255 acb
->hd_aiocb
= bdrv_aio_read(bs
->backing_hd
, acb
->sector_num
,
1256 acb
->buf
, acb
->n
, qcow_aio_read_cb
, acb
);
1257 if (acb
->hd_aiocb
== NULL
)
1260 ret
= qcow_schedule_bh(qcow_aio_read_bh
, acb
);
1265 /* Note: in this case, no need to wait */
1266 memset(acb
->buf
, 0, 512 * acb
->n
);
1267 ret
= qcow_schedule_bh(qcow_aio_read_bh
, acb
);
1271 } else if (acb
->cluster_offset
& QCOW_OFLAG_COMPRESSED
) {
1272 /* add AIO support for compressed blocks ? */
1273 if (decompress_cluster(s
, acb
->cluster_offset
) < 0)
1276 s
->cluster_cache
+ index_in_cluster
* 512, 512 * acb
->n
);
1277 ret
= qcow_schedule_bh(qcow_aio_read_bh
, acb
);
1281 if ((acb
->cluster_offset
& 511) != 0) {
1285 acb
->hd_aiocb
= bdrv_aio_read(s
->hd
,
1286 (acb
->cluster_offset
>> 9) + index_in_cluster
,
1287 acb
->buf
, acb
->n
, qcow_aio_read_cb
, acb
);
1288 if (acb
->hd_aiocb
== NULL
)
1293 static QCowAIOCB
*qcow_aio_setup(BlockDriverState
*bs
,
1294 int64_t sector_num
, uint8_t *buf
, int nb_sectors
,
1295 BlockDriverCompletionFunc
*cb
, void *opaque
)
1299 acb
= qemu_aio_get(bs
, cb
, opaque
);
1302 acb
->hd_aiocb
= NULL
;
1303 acb
->sector_num
= sector_num
;
1305 acb
->nb_sectors
= nb_sectors
;
1307 acb
->cluster_offset
= 0;
1308 acb
->l2meta
.nb_clusters
= 0;
1312 static BlockDriverAIOCB
*qcow_aio_read(BlockDriverState
*bs
,
1313 int64_t sector_num
, uint8_t *buf
, int nb_sectors
,
1314 BlockDriverCompletionFunc
*cb
, void *opaque
)
1318 acb
= qcow_aio_setup(bs
, sector_num
, buf
, nb_sectors
, cb
, opaque
);
1322 qcow_aio_read_cb(acb
, 0);
1323 return &acb
->common
;
1326 static void qcow_aio_write_cb(void *opaque
, int ret
)
1328 QCowAIOCB
*acb
= opaque
;
1329 BlockDriverState
*bs
= acb
->common
.bs
;
1330 BDRVQcowState
*s
= bs
->opaque
;
1331 int index_in_cluster
;
1332 const uint8_t *src_buf
;
1335 acb
->hd_aiocb
= NULL
;
1339 acb
->common
.cb(acb
->common
.opaque
, ret
);
1340 qemu_aio_release(acb
);
1344 if (alloc_cluster_link_l2(bs
, acb
->cluster_offset
, &acb
->l2meta
) < 0) {
1345 free_any_clusters(bs
, acb
->cluster_offset
, acb
->l2meta
.nb_clusters
);
1349 acb
->nb_sectors
-= acb
->n
;
1350 acb
->sector_num
+= acb
->n
;
1351 acb
->buf
+= acb
->n
* 512;
1353 if (acb
->nb_sectors
== 0) {
1354 /* request completed */
1355 acb
->common
.cb(acb
->common
.opaque
, 0);
1356 qemu_aio_release(acb
);
1360 index_in_cluster
= acb
->sector_num
& (s
->cluster_sectors
- 1);
1361 n_end
= index_in_cluster
+ acb
->nb_sectors
;
1362 if (s
->crypt_method
&&
1363 n_end
> QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_sectors
)
1364 n_end
= QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_sectors
;
1366 acb
->cluster_offset
= alloc_cluster_offset(bs
, acb
->sector_num
<< 9,
1368 n_end
, &acb
->n
, &acb
->l2meta
);
1369 if (!acb
->cluster_offset
|| (acb
->cluster_offset
& 511) != 0) {
1373 if (s
->crypt_method
) {
1374 if (!acb
->cluster_data
) {
1375 acb
->cluster_data
= qemu_mallocz(QCOW_MAX_CRYPT_CLUSTERS
*
1377 if (!acb
->cluster_data
) {
1382 encrypt_sectors(s
, acb
->sector_num
, acb
->cluster_data
, acb
->buf
,
1383 acb
->n
, 1, &s
->aes_encrypt_key
);
1384 src_buf
= acb
->cluster_data
;
1388 acb
->hd_aiocb
= bdrv_aio_write(s
->hd
,
1389 (acb
->cluster_offset
>> 9) + index_in_cluster
,
1391 qcow_aio_write_cb
, acb
);
1392 if (acb
->hd_aiocb
== NULL
)
1396 static BlockDriverAIOCB
*qcow_aio_write(BlockDriverState
*bs
,
1397 int64_t sector_num
, const uint8_t *buf
, int nb_sectors
,
1398 BlockDriverCompletionFunc
*cb
, void *opaque
)
1400 BDRVQcowState
*s
= bs
->opaque
;
1403 s
->cluster_cache_offset
= -1; /* disable compressed cache */
1405 acb
= qcow_aio_setup(bs
, sector_num
, (uint8_t*)buf
, nb_sectors
, cb
, opaque
);
1409 qcow_aio_write_cb(acb
, 0);
1410 return &acb
->common
;
1413 static void qcow_aio_cancel(BlockDriverAIOCB
*blockacb
)
1415 QCowAIOCB
*acb
= (QCowAIOCB
*)blockacb
;
1417 bdrv_aio_cancel(acb
->hd_aiocb
);
1418 qemu_aio_release(acb
);
1421 static void qcow_close(BlockDriverState
*bs
)
1423 BDRVQcowState
*s
= bs
->opaque
;
1424 qemu_free(s
->l1_table
);
1425 qemu_free(s
->l2_cache
);
1426 qemu_free(s
->cluster_cache
);
1427 qemu_free(s
->cluster_data
);
1432 /* XXX: use std qcow open function ? */
1433 typedef struct QCowCreateState
{
1436 uint16_t *refcount_block
;
1437 uint64_t *refcount_table
;
1438 int64_t l1_table_offset
;
1439 int64_t refcount_table_offset
;
1440 int64_t refcount_block_offset
;
1443 static void create_refcount_update(QCowCreateState
*s
,
1444 int64_t offset
, int64_t size
)
1447 int64_t start
, last
, cluster_offset
;
1450 start
= offset
& ~(s
->cluster_size
- 1);
1451 last
= (offset
+ size
- 1) & ~(s
->cluster_size
- 1);
1452 for(cluster_offset
= start
; cluster_offset
<= last
;
1453 cluster_offset
+= s
->cluster_size
) {
1454 p
= &s
->refcount_block
[cluster_offset
>> s
->cluster_bits
];
1455 refcount
= be16_to_cpu(*p
);
1457 *p
= cpu_to_be16(refcount
);
1461 static int qcow_create(const char *filename
, int64_t total_size
,
1462 const char *backing_file
, int flags
)
1464 int fd
, header_size
, backing_filename_len
, l1_size
, i
, shift
, l2_bits
;
1466 uint64_t tmp
, offset
;
1467 QCowCreateState s1
, *s
= &s1
;
1469 memset(s
, 0, sizeof(*s
));
1471 fd
= open(filename
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_BINARY
, 0644);
1474 memset(&header
, 0, sizeof(header
));
1475 header
.magic
= cpu_to_be32(QCOW_MAGIC
);
1476 header
.version
= cpu_to_be32(QCOW_VERSION
);
1477 header
.size
= cpu_to_be64(total_size
* 512);
1478 header_size
= sizeof(header
);
1479 backing_filename_len
= 0;
1481 header
.backing_file_offset
= cpu_to_be64(header_size
);
1482 backing_filename_len
= strlen(backing_file
);
1483 header
.backing_file_size
= cpu_to_be32(backing_filename_len
);
1484 header_size
+= backing_filename_len
;
1486 s
->cluster_bits
= 12; /* 4 KB clusters */
1487 s
->cluster_size
= 1 << s
->cluster_bits
;
1488 header
.cluster_bits
= cpu_to_be32(s
->cluster_bits
);
1489 header_size
= (header_size
+ 7) & ~7;
1490 if (flags
& BLOCK_FLAG_ENCRYPT
) {
1491 header
.crypt_method
= cpu_to_be32(QCOW_CRYPT_AES
);
1493 header
.crypt_method
= cpu_to_be32(QCOW_CRYPT_NONE
);
1495 l2_bits
= s
->cluster_bits
- 3;
1496 shift
= s
->cluster_bits
+ l2_bits
;
1497 l1_size
= (((total_size
* 512) + (1LL << shift
) - 1) >> shift
);
1498 offset
= align_offset(header_size
, s
->cluster_size
);
1499 s
->l1_table_offset
= offset
;
1500 header
.l1_table_offset
= cpu_to_be64(s
->l1_table_offset
);
1501 header
.l1_size
= cpu_to_be32(l1_size
);
1502 offset
+= align_offset(l1_size
* sizeof(uint64_t), s
->cluster_size
);
1504 s
->refcount_table
= qemu_mallocz(s
->cluster_size
);
1505 if (!s
->refcount_table
)
1507 s
->refcount_block
= qemu_mallocz(s
->cluster_size
);
1508 if (!s
->refcount_block
)
1511 s
->refcount_table_offset
= offset
;
1512 header
.refcount_table_offset
= cpu_to_be64(offset
);
1513 header
.refcount_table_clusters
= cpu_to_be32(1);
1514 offset
+= s
->cluster_size
;
1516 s
->refcount_table
[0] = cpu_to_be64(offset
);
1517 s
->refcount_block_offset
= offset
;
1518 offset
+= s
->cluster_size
;
1520 /* update refcounts */
1521 create_refcount_update(s
, 0, header_size
);
1522 create_refcount_update(s
, s
->l1_table_offset
, l1_size
* sizeof(uint64_t));
1523 create_refcount_update(s
, s
->refcount_table_offset
, s
->cluster_size
);
1524 create_refcount_update(s
, s
->refcount_block_offset
, s
->cluster_size
);
1526 /* write all the data */
1527 write(fd
, &header
, sizeof(header
));
1529 write(fd
, backing_file
, backing_filename_len
);
1531 lseek(fd
, s
->l1_table_offset
, SEEK_SET
);
1533 for(i
= 0;i
< l1_size
; i
++) {
1534 write(fd
, &tmp
, sizeof(tmp
));
1536 lseek(fd
, s
->refcount_table_offset
, SEEK_SET
);
1537 write(fd
, s
->refcount_table
, s
->cluster_size
);
1539 lseek(fd
, s
->refcount_block_offset
, SEEK_SET
);
1540 write(fd
, s
->refcount_block
, s
->cluster_size
);
1542 qemu_free(s
->refcount_table
);
1543 qemu_free(s
->refcount_block
);
1547 qemu_free(s
->refcount_table
);
1548 qemu_free(s
->refcount_block
);
1553 static int qcow_make_empty(BlockDriverState
*bs
)
1556 /* XXX: not correct */
1557 BDRVQcowState
*s
= bs
->opaque
;
1558 uint32_t l1_length
= s
->l1_size
* sizeof(uint64_t);
1561 memset(s
->l1_table
, 0, l1_length
);
1562 if (bdrv_pwrite(s
->hd
, s
->l1_table_offset
, s
->l1_table
, l1_length
) < 0)
1564 ret
= bdrv_truncate(s
->hd
, s
->l1_table_offset
+ l1_length
);
1573 /* XXX: put compressed sectors first, then all the cluster aligned
1574 tables to avoid losing bytes in alignment */
1575 static int qcow_write_compressed(BlockDriverState
*bs
, int64_t sector_num
,
1576 const uint8_t *buf
, int nb_sectors
)
1578 BDRVQcowState
*s
= bs
->opaque
;
1582 uint64_t cluster_offset
;
1584 if (nb_sectors
== 0) {
1585 /* align end of file to a sector boundary to ease reading with
1586 sector based I/Os */
1587 cluster_offset
= bdrv_getlength(s
->hd
);
1588 cluster_offset
= (cluster_offset
+ 511) & ~511;
1589 bdrv_truncate(s
->hd
, cluster_offset
);
1593 if (nb_sectors
!= s
->cluster_sectors
)
1596 out_buf
= qemu_malloc(s
->cluster_size
+ (s
->cluster_size
/ 1000) + 128);
1600 /* best compression, small window, no zlib header */
1601 memset(&strm
, 0, sizeof(strm
));
1602 ret
= deflateInit2(&strm
, Z_DEFAULT_COMPRESSION
,
1604 9, Z_DEFAULT_STRATEGY
);
1610 strm
.avail_in
= s
->cluster_size
;
1611 strm
.next_in
= (uint8_t *)buf
;
1612 strm
.avail_out
= s
->cluster_size
;
1613 strm
.next_out
= out_buf
;
1615 ret
= deflate(&strm
, Z_FINISH
);
1616 if (ret
!= Z_STREAM_END
&& ret
!= Z_OK
) {
1621 out_len
= strm
.next_out
- out_buf
;
1625 if (ret
!= Z_STREAM_END
|| out_len
>= s
->cluster_size
) {
1626 /* could not compress: write normal cluster */
1627 qcow_write(bs
, sector_num
, buf
, s
->cluster_sectors
);
1629 cluster_offset
= alloc_compressed_cluster_offset(bs
, sector_num
<< 9,
1631 if (!cluster_offset
)
1633 cluster_offset
&= s
->cluster_offset_mask
;
1634 if (bdrv_pwrite(s
->hd
, cluster_offset
, out_buf
, out_len
) != out_len
) {
1644 static void qcow_flush(BlockDriverState
*bs
)
1646 BDRVQcowState
*s
= bs
->opaque
;
1650 static int qcow_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
1652 BDRVQcowState
*s
= bs
->opaque
;
1653 bdi
->cluster_size
= s
->cluster_size
;
1654 bdi
->vm_state_offset
= (int64_t)s
->l1_vm_state_index
<<
1655 (s
->cluster_bits
+ s
->l2_bits
);
1659 /*********************************************************/
1660 /* snapshot support */
1662 /* update the refcounts of snapshots and the copied flag */
1663 static int update_snapshot_refcount(BlockDriverState
*bs
,
1664 int64_t l1_table_offset
,
1668 BDRVQcowState
*s
= bs
->opaque
;
1669 uint64_t *l1_table
, *l2_table
, l2_offset
, offset
, l1_size2
, l1_allocated
;
1670 int64_t old_offset
, old_l2_offset
;
1671 int l2_size
, i
, j
, l1_modified
, l2_modified
, nb_csectors
, refcount
;
1677 l1_size2
= l1_size
* sizeof(uint64_t);
1679 if (l1_table_offset
!= s
->l1_table_offset
) {
1680 l1_table
= qemu_malloc(l1_size2
);
1684 if (bdrv_pread(s
->hd
, l1_table_offset
,
1685 l1_table
, l1_size2
) != l1_size2
)
1687 for(i
= 0;i
< l1_size
; i
++)
1688 be64_to_cpus(&l1_table
[i
]);
1690 assert(l1_size
== s
->l1_size
);
1691 l1_table
= s
->l1_table
;
1695 l2_size
= s
->l2_size
* sizeof(uint64_t);
1696 l2_table
= qemu_malloc(l2_size
);
1700 for(i
= 0; i
< l1_size
; i
++) {
1701 l2_offset
= l1_table
[i
];
1703 old_l2_offset
= l2_offset
;
1704 l2_offset
&= ~QCOW_OFLAG_COPIED
;
1706 if (bdrv_pread(s
->hd
, l2_offset
, l2_table
, l2_size
) != l2_size
)
1708 for(j
= 0; j
< s
->l2_size
; j
++) {
1709 offset
= be64_to_cpu(l2_table
[j
]);
1711 old_offset
= offset
;
1712 offset
&= ~QCOW_OFLAG_COPIED
;
1713 if (offset
& QCOW_OFLAG_COMPRESSED
) {
1714 nb_csectors
= ((offset
>> s
->csize_shift
) &
1717 update_refcount(bs
, (offset
& s
->cluster_offset_mask
) & ~511,
1718 nb_csectors
* 512, addend
);
1719 /* compressed clusters are never modified */
1723 refcount
= update_cluster_refcount(bs
, offset
>> s
->cluster_bits
, addend
);
1725 refcount
= get_refcount(bs
, offset
>> s
->cluster_bits
);
1729 if (refcount
== 1) {
1730 offset
|= QCOW_OFLAG_COPIED
;
1732 if (offset
!= old_offset
) {
1733 l2_table
[j
] = cpu_to_be64(offset
);
1739 if (bdrv_pwrite(s
->hd
,
1740 l2_offset
, l2_table
, l2_size
) != l2_size
)
1745 refcount
= update_cluster_refcount(bs
, l2_offset
>> s
->cluster_bits
, addend
);
1747 refcount
= get_refcount(bs
, l2_offset
>> s
->cluster_bits
);
1749 if (refcount
== 1) {
1750 l2_offset
|= QCOW_OFLAG_COPIED
;
1752 if (l2_offset
!= old_l2_offset
) {
1753 l1_table
[i
] = l2_offset
;
1759 for(i
= 0; i
< l1_size
; i
++)
1760 cpu_to_be64s(&l1_table
[i
]);
1761 if (bdrv_pwrite(s
->hd
, l1_table_offset
, l1_table
,
1762 l1_size2
) != l1_size2
)
1764 for(i
= 0; i
< l1_size
; i
++)
1765 be64_to_cpus(&l1_table
[i
]);
1768 qemu_free(l1_table
);
1769 qemu_free(l2_table
);
1773 qemu_free(l1_table
);
1774 qemu_free(l2_table
);
1778 static void qcow_free_snapshots(BlockDriverState
*bs
)
1780 BDRVQcowState
*s
= bs
->opaque
;
1783 for(i
= 0; i
< s
->nb_snapshots
; i
++) {
1784 qemu_free(s
->snapshots
[i
].name
);
1785 qemu_free(s
->snapshots
[i
].id_str
);
1787 qemu_free(s
->snapshots
);
1788 s
->snapshots
= NULL
;
1789 s
->nb_snapshots
= 0;
1792 static int qcow_read_snapshots(BlockDriverState
*bs
)
1794 BDRVQcowState
*s
= bs
->opaque
;
1795 QCowSnapshotHeader h
;
1797 int i
, id_str_size
, name_size
;
1799 uint32_t extra_data_size
;
1801 offset
= s
->snapshots_offset
;
1802 s
->snapshots
= qemu_mallocz(s
->nb_snapshots
* sizeof(QCowSnapshot
));
1805 for(i
= 0; i
< s
->nb_snapshots
; i
++) {
1806 offset
= align_offset(offset
, 8);
1807 if (bdrv_pread(s
->hd
, offset
, &h
, sizeof(h
)) != sizeof(h
))
1809 offset
+= sizeof(h
);
1810 sn
= s
->snapshots
+ i
;
1811 sn
->l1_table_offset
= be64_to_cpu(h
.l1_table_offset
);
1812 sn
->l1_size
= be32_to_cpu(h
.l1_size
);
1813 sn
->vm_state_size
= be32_to_cpu(h
.vm_state_size
);
1814 sn
->date_sec
= be32_to_cpu(h
.date_sec
);
1815 sn
->date_nsec
= be32_to_cpu(h
.date_nsec
);
1816 sn
->vm_clock_nsec
= be64_to_cpu(h
.vm_clock_nsec
);
1817 extra_data_size
= be32_to_cpu(h
.extra_data_size
);
1819 id_str_size
= be16_to_cpu(h
.id_str_size
);
1820 name_size
= be16_to_cpu(h
.name_size
);
1822 offset
+= extra_data_size
;
1824 sn
->id_str
= qemu_malloc(id_str_size
+ 1);
1827 if (bdrv_pread(s
->hd
, offset
, sn
->id_str
, id_str_size
) != id_str_size
)
1829 offset
+= id_str_size
;
1830 sn
->id_str
[id_str_size
] = '\0';
1832 sn
->name
= qemu_malloc(name_size
+ 1);
1835 if (bdrv_pread(s
->hd
, offset
, sn
->name
, name_size
) != name_size
)
1837 offset
+= name_size
;
1838 sn
->name
[name_size
] = '\0';
1840 s
->snapshots_size
= offset
- s
->snapshots_offset
;
1843 qcow_free_snapshots(bs
);
1847 /* add at the end of the file a new list of snapshots */
1848 static int qcow_write_snapshots(BlockDriverState
*bs
)
1850 BDRVQcowState
*s
= bs
->opaque
;
1852 QCowSnapshotHeader h
;
1853 int i
, name_size
, id_str_size
, snapshots_size
;
1856 int64_t offset
, snapshots_offset
;
1858 /* compute the size of the snapshots */
1860 for(i
= 0; i
< s
->nb_snapshots
; i
++) {
1861 sn
= s
->snapshots
+ i
;
1862 offset
= align_offset(offset
, 8);
1863 offset
+= sizeof(h
);
1864 offset
+= strlen(sn
->id_str
);
1865 offset
+= strlen(sn
->name
);
1867 snapshots_size
= offset
;
1869 snapshots_offset
= alloc_clusters(bs
, snapshots_size
);
1870 offset
= snapshots_offset
;
1872 for(i
= 0; i
< s
->nb_snapshots
; i
++) {
1873 sn
= s
->snapshots
+ i
;
1874 memset(&h
, 0, sizeof(h
));
1875 h
.l1_table_offset
= cpu_to_be64(sn
->l1_table_offset
);
1876 h
.l1_size
= cpu_to_be32(sn
->l1_size
);
1877 h
.vm_state_size
= cpu_to_be32(sn
->vm_state_size
);
1878 h
.date_sec
= cpu_to_be32(sn
->date_sec
);
1879 h
.date_nsec
= cpu_to_be32(sn
->date_nsec
);
1880 h
.vm_clock_nsec
= cpu_to_be64(sn
->vm_clock_nsec
);
1882 id_str_size
= strlen(sn
->id_str
);
1883 name_size
= strlen(sn
->name
);
1884 h
.id_str_size
= cpu_to_be16(id_str_size
);
1885 h
.name_size
= cpu_to_be16(name_size
);
1886 offset
= align_offset(offset
, 8);
1887 if (bdrv_pwrite(s
->hd
, offset
, &h
, sizeof(h
)) != sizeof(h
))
1889 offset
+= sizeof(h
);
1890 if (bdrv_pwrite(s
->hd
, offset
, sn
->id_str
, id_str_size
) != id_str_size
)
1892 offset
+= id_str_size
;
1893 if (bdrv_pwrite(s
->hd
, offset
, sn
->name
, name_size
) != name_size
)
1895 offset
+= name_size
;
1898 /* update the various header fields */
1899 data64
= cpu_to_be64(snapshots_offset
);
1900 if (bdrv_pwrite(s
->hd
, offsetof(QCowHeader
, snapshots_offset
),
1901 &data64
, sizeof(data64
)) != sizeof(data64
))
1903 data32
= cpu_to_be32(s
->nb_snapshots
);
1904 if (bdrv_pwrite(s
->hd
, offsetof(QCowHeader
, nb_snapshots
),
1905 &data32
, sizeof(data32
)) != sizeof(data32
))
1908 /* free the old snapshot table */
1909 free_clusters(bs
, s
->snapshots_offset
, s
->snapshots_size
);
1910 s
->snapshots_offset
= snapshots_offset
;
1911 s
->snapshots_size
= snapshots_size
;
1917 static void find_new_snapshot_id(BlockDriverState
*bs
,
1918 char *id_str
, int id_str_size
)
1920 BDRVQcowState
*s
= bs
->opaque
;
1922 int i
, id
, id_max
= 0;
1924 for(i
= 0; i
< s
->nb_snapshots
; i
++) {
1925 sn
= s
->snapshots
+ i
;
1926 id
= strtoul(sn
->id_str
, NULL
, 10);
1930 snprintf(id_str
, id_str_size
, "%d", id_max
+ 1);
1933 static int find_snapshot_by_id(BlockDriverState
*bs
, const char *id_str
)
1935 BDRVQcowState
*s
= bs
->opaque
;
1938 for(i
= 0; i
< s
->nb_snapshots
; i
++) {
1939 if (!strcmp(s
->snapshots
[i
].id_str
, id_str
))
1945 static int find_snapshot_by_id_or_name(BlockDriverState
*bs
, const char *name
)
1947 BDRVQcowState
*s
= bs
->opaque
;
1950 ret
= find_snapshot_by_id(bs
, name
);
1953 for(i
= 0; i
< s
->nb_snapshots
; i
++) {
1954 if (!strcmp(s
->snapshots
[i
].name
, name
))
1960 /* if no id is provided, a new one is constructed */
1961 static int qcow_snapshot_create(BlockDriverState
*bs
,
1962 QEMUSnapshotInfo
*sn_info
)
1964 BDRVQcowState
*s
= bs
->opaque
;
1965 QCowSnapshot
*snapshots1
, sn1
, *sn
= &sn1
;
1967 uint64_t *l1_table
= NULL
;
1969 memset(sn
, 0, sizeof(*sn
));
1971 if (sn_info
->id_str
[0] == '\0') {
1972 /* compute a new id */
1973 find_new_snapshot_id(bs
, sn_info
->id_str
, sizeof(sn_info
->id_str
));
1976 /* check that the ID is unique */
1977 if (find_snapshot_by_id(bs
, sn_info
->id_str
) >= 0)
1980 sn
->id_str
= qemu_strdup(sn_info
->id_str
);
1983 sn
->name
= qemu_strdup(sn_info
->name
);
1986 sn
->vm_state_size
= sn_info
->vm_state_size
;
1987 sn
->date_sec
= sn_info
->date_sec
;
1988 sn
->date_nsec
= sn_info
->date_nsec
;
1989 sn
->vm_clock_nsec
= sn_info
->vm_clock_nsec
;
1991 ret
= update_snapshot_refcount(bs
, s
->l1_table_offset
, s
->l1_size
, 1);
1995 /* create the L1 table of the snapshot */
1996 sn
->l1_table_offset
= alloc_clusters(bs
, s
->l1_size
* sizeof(uint64_t));
1997 sn
->l1_size
= s
->l1_size
;
1999 l1_table
= qemu_malloc(s
->l1_size
* sizeof(uint64_t));
2002 for(i
= 0; i
< s
->l1_size
; i
++) {
2003 l1_table
[i
] = cpu_to_be64(s
->l1_table
[i
]);
2005 if (bdrv_pwrite(s
->hd
, sn
->l1_table_offset
,
2006 l1_table
, s
->l1_size
* sizeof(uint64_t)) !=
2007 (s
->l1_size
* sizeof(uint64_t)))
2009 qemu_free(l1_table
);
2012 snapshots1
= qemu_malloc((s
->nb_snapshots
+ 1) * sizeof(QCowSnapshot
));
2015 memcpy(snapshots1
, s
->snapshots
, s
->nb_snapshots
* sizeof(QCowSnapshot
));
2016 s
->snapshots
= snapshots1
;
2017 s
->snapshots
[s
->nb_snapshots
++] = *sn
;
2019 if (qcow_write_snapshots(bs
) < 0)
2022 check_refcounts(bs
);
2026 qemu_free(sn
->name
);
2027 qemu_free(l1_table
);
2031 /* copy the snapshot 'snapshot_name' into the current disk image */
2032 static int qcow_snapshot_goto(BlockDriverState
*bs
,
2033 const char *snapshot_id
)
2035 BDRVQcowState
*s
= bs
->opaque
;
2037 int i
, snapshot_index
, l1_size2
;
2039 snapshot_index
= find_snapshot_by_id_or_name(bs
, snapshot_id
);
2040 if (snapshot_index
< 0)
2042 sn
= &s
->snapshots
[snapshot_index
];
2044 if (update_snapshot_refcount(bs
, s
->l1_table_offset
, s
->l1_size
, -1) < 0)
2047 if (grow_l1_table(bs
, sn
->l1_size
) < 0)
2050 s
->l1_size
= sn
->l1_size
;
2051 l1_size2
= s
->l1_size
* sizeof(uint64_t);
2052 /* copy the snapshot l1 table to the current l1 table */
2053 if (bdrv_pread(s
->hd
, sn
->l1_table_offset
,
2054 s
->l1_table
, l1_size2
) != l1_size2
)
2056 if (bdrv_pwrite(s
->hd
, s
->l1_table_offset
,
2057 s
->l1_table
, l1_size2
) != l1_size2
)
2059 for(i
= 0;i
< s
->l1_size
; i
++) {
2060 be64_to_cpus(&s
->l1_table
[i
]);
2063 if (update_snapshot_refcount(bs
, s
->l1_table_offset
, s
->l1_size
, 1) < 0)
2067 check_refcounts(bs
);
2074 static int qcow_snapshot_delete(BlockDriverState
*bs
, const char *snapshot_id
)
2076 BDRVQcowState
*s
= bs
->opaque
;
2078 int snapshot_index
, ret
;
2080 snapshot_index
= find_snapshot_by_id_or_name(bs
, snapshot_id
);
2081 if (snapshot_index
< 0)
2083 sn
= &s
->snapshots
[snapshot_index
];
2085 ret
= update_snapshot_refcount(bs
, sn
->l1_table_offset
, sn
->l1_size
, -1);
2088 /* must update the copied flag on the current cluster offsets */
2089 ret
= update_snapshot_refcount(bs
, s
->l1_table_offset
, s
->l1_size
, 0);
2092 free_clusters(bs
, sn
->l1_table_offset
, sn
->l1_size
* sizeof(uint64_t));
2094 qemu_free(sn
->id_str
);
2095 qemu_free(sn
->name
);
2096 memmove(sn
, sn
+ 1, (s
->nb_snapshots
- snapshot_index
- 1) * sizeof(*sn
));
2098 ret
= qcow_write_snapshots(bs
);
2100 /* XXX: restore snapshot if error ? */
2104 check_refcounts(bs
);
2109 static int qcow_snapshot_list(BlockDriverState
*bs
,
2110 QEMUSnapshotInfo
**psn_tab
)
2112 BDRVQcowState
*s
= bs
->opaque
;
2113 QEMUSnapshotInfo
*sn_tab
, *sn_info
;
2117 sn_tab
= qemu_mallocz(s
->nb_snapshots
* sizeof(QEMUSnapshotInfo
));
2120 for(i
= 0; i
< s
->nb_snapshots
; i
++) {
2121 sn_info
= sn_tab
+ i
;
2122 sn
= s
->snapshots
+ i
;
2123 pstrcpy(sn_info
->id_str
, sizeof(sn_info
->id_str
),
2125 pstrcpy(sn_info
->name
, sizeof(sn_info
->name
),
2127 sn_info
->vm_state_size
= sn
->vm_state_size
;
2128 sn_info
->date_sec
= sn
->date_sec
;
2129 sn_info
->date_nsec
= sn
->date_nsec
;
2130 sn_info
->vm_clock_nsec
= sn
->vm_clock_nsec
;
2133 return s
->nb_snapshots
;
2140 /*********************************************************/
2141 /* refcount handling */
2143 static int refcount_init(BlockDriverState
*bs
)
2145 BDRVQcowState
*s
= bs
->opaque
;
2146 int ret
, refcount_table_size2
, i
;
2148 s
->refcount_block_cache
= qemu_malloc(s
->cluster_size
);
2149 if (!s
->refcount_block_cache
)
2151 refcount_table_size2
= s
->refcount_table_size
* sizeof(uint64_t);
2152 s
->refcount_table
= qemu_malloc(refcount_table_size2
);
2153 if (!s
->refcount_table
)
2155 if (s
->refcount_table_size
> 0) {
2156 ret
= bdrv_pread(s
->hd
, s
->refcount_table_offset
,
2157 s
->refcount_table
, refcount_table_size2
);
2158 if (ret
!= refcount_table_size2
)
2160 for(i
= 0; i
< s
->refcount_table_size
; i
++)
2161 be64_to_cpus(&s
->refcount_table
[i
]);
2168 static void refcount_close(BlockDriverState
*bs
)
2170 BDRVQcowState
*s
= bs
->opaque
;
2171 qemu_free(s
->refcount_block_cache
);
2172 qemu_free(s
->refcount_table
);
2176 static int load_refcount_block(BlockDriverState
*bs
,
2177 int64_t refcount_block_offset
)
2179 BDRVQcowState
*s
= bs
->opaque
;
2181 ret
= bdrv_pread(s
->hd
, refcount_block_offset
, s
->refcount_block_cache
,
2183 if (ret
!= s
->cluster_size
)
2185 s
->refcount_block_cache_offset
= refcount_block_offset
;
2189 static int get_refcount(BlockDriverState
*bs
, int64_t cluster_index
)
2191 BDRVQcowState
*s
= bs
->opaque
;
2192 int refcount_table_index
, block_index
;
2193 int64_t refcount_block_offset
;
2195 refcount_table_index
= cluster_index
>> (s
->cluster_bits
- REFCOUNT_SHIFT
);
2196 if (refcount_table_index
>= s
->refcount_table_size
)
2198 refcount_block_offset
= s
->refcount_table
[refcount_table_index
];
2199 if (!refcount_block_offset
)
2201 if (refcount_block_offset
!= s
->refcount_block_cache_offset
) {
2202 /* better than nothing: return allocated if read error */
2203 if (load_refcount_block(bs
, refcount_block_offset
) < 0)
2206 block_index
= cluster_index
&
2207 ((1 << (s
->cluster_bits
- REFCOUNT_SHIFT
)) - 1);
2208 return be16_to_cpu(s
->refcount_block_cache
[block_index
]);
2211 /* return < 0 if error */
2212 static int64_t alloc_clusters_noref(BlockDriverState
*bs
, int64_t size
)
2214 BDRVQcowState
*s
= bs
->opaque
;
2217 nb_clusters
= size_to_clusters(s
, size
);
2219 for(i
= 0; i
< nb_clusters
; i
++) {
2220 int64_t i
= s
->free_cluster_index
++;
2221 if (get_refcount(bs
, i
) != 0)
2225 printf("alloc_clusters: size=%lld -> %lld\n",
2227 (s
->free_cluster_index
- nb_clusters
) << s
->cluster_bits
);
2229 return (s
->free_cluster_index
- nb_clusters
) << s
->cluster_bits
;
2232 static int64_t alloc_clusters(BlockDriverState
*bs
, int64_t size
)
2236 offset
= alloc_clusters_noref(bs
, size
);
2237 update_refcount(bs
, offset
, size
, 1);
2241 /* only used to allocate compressed sectors. We try to allocate
2242 contiguous sectors. size must be <= cluster_size */
2243 static int64_t alloc_bytes(BlockDriverState
*bs
, int size
)
2245 BDRVQcowState
*s
= bs
->opaque
;
2246 int64_t offset
, cluster_offset
;
2247 int free_in_cluster
;
2249 assert(size
> 0 && size
<= s
->cluster_size
);
2250 if (s
->free_byte_offset
== 0) {
2251 s
->free_byte_offset
= alloc_clusters(bs
, s
->cluster_size
);
2254 free_in_cluster
= s
->cluster_size
-
2255 (s
->free_byte_offset
& (s
->cluster_size
- 1));
2256 if (size
<= free_in_cluster
) {
2257 /* enough space in current cluster */
2258 offset
= s
->free_byte_offset
;
2259 s
->free_byte_offset
+= size
;
2260 free_in_cluster
-= size
;
2261 if (free_in_cluster
== 0)
2262 s
->free_byte_offset
= 0;
2263 if ((offset
& (s
->cluster_size
- 1)) != 0)
2264 update_cluster_refcount(bs
, offset
>> s
->cluster_bits
, 1);
2266 offset
= alloc_clusters(bs
, s
->cluster_size
);
2267 cluster_offset
= s
->free_byte_offset
& ~(s
->cluster_size
- 1);
2268 if ((cluster_offset
+ s
->cluster_size
) == offset
) {
2269 /* we are lucky: contiguous data */
2270 offset
= s
->free_byte_offset
;
2271 update_cluster_refcount(bs
, offset
>> s
->cluster_bits
, 1);
2272 s
->free_byte_offset
+= size
;
2274 s
->free_byte_offset
= offset
;
2281 static void free_clusters(BlockDriverState
*bs
,
2282 int64_t offset
, int64_t size
)
2284 update_refcount(bs
, offset
, size
, -1);
2287 static int grow_refcount_table(BlockDriverState
*bs
, int min_size
)
2289 BDRVQcowState
*s
= bs
->opaque
;
2290 int new_table_size
, new_table_size2
, refcount_table_clusters
, i
, ret
;
2291 uint64_t *new_table
;
2292 int64_t table_offset
;
2295 int64_t old_table_offset
;
2297 if (min_size
<= s
->refcount_table_size
)
2299 /* compute new table size */
2300 refcount_table_clusters
= s
->refcount_table_size
>> (s
->cluster_bits
- 3);
2302 if (refcount_table_clusters
== 0) {
2303 refcount_table_clusters
= 1;
2305 refcount_table_clusters
= (refcount_table_clusters
* 3 + 1) / 2;
2307 new_table_size
= refcount_table_clusters
<< (s
->cluster_bits
- 3);
2308 if (min_size
<= new_table_size
)
2312 printf("grow_refcount_table from %d to %d\n",
2313 s
->refcount_table_size
,
2316 new_table_size2
= new_table_size
* sizeof(uint64_t);
2317 new_table
= qemu_mallocz(new_table_size2
);
2320 memcpy(new_table
, s
->refcount_table
,
2321 s
->refcount_table_size
* sizeof(uint64_t));
2322 for(i
= 0; i
< s
->refcount_table_size
; i
++)
2323 cpu_to_be64s(&new_table
[i
]);
2324 /* Note: we cannot update the refcount now to avoid recursion */
2325 table_offset
= alloc_clusters_noref(bs
, new_table_size2
);
2326 ret
= bdrv_pwrite(s
->hd
, table_offset
, new_table
, new_table_size2
);
2327 if (ret
!= new_table_size2
)
2329 for(i
= 0; i
< s
->refcount_table_size
; i
++)
2330 be64_to_cpus(&new_table
[i
]);
2332 cpu_to_be64w((uint64_t*)data
, table_offset
);
2333 cpu_to_be32w((uint32_t*)(data
+ 8), refcount_table_clusters
);
2334 if (bdrv_pwrite(s
->hd
, offsetof(QCowHeader
, refcount_table_offset
),
2335 data
, sizeof(data
)) != sizeof(data
))
2337 qemu_free(s
->refcount_table
);
2338 old_table_offset
= s
->refcount_table_offset
;
2339 old_table_size
= s
->refcount_table_size
;
2340 s
->refcount_table
= new_table
;
2341 s
->refcount_table_size
= new_table_size
;
2342 s
->refcount_table_offset
= table_offset
;
2344 update_refcount(bs
, table_offset
, new_table_size2
, 1);
2345 free_clusters(bs
, old_table_offset
, old_table_size
* sizeof(uint64_t));
2348 free_clusters(bs
, table_offset
, new_table_size2
);
2349 qemu_free(new_table
);
2353 /* addend must be 1 or -1 */
2354 /* XXX: cache several refcount block clusters ? */
2355 static int update_cluster_refcount(BlockDriverState
*bs
,
2356 int64_t cluster_index
,
2359 BDRVQcowState
*s
= bs
->opaque
;
2360 int64_t offset
, refcount_block_offset
;
2361 int ret
, refcount_table_index
, block_index
, refcount
;
2364 refcount_table_index
= cluster_index
>> (s
->cluster_bits
- REFCOUNT_SHIFT
);
2365 if (refcount_table_index
>= s
->refcount_table_size
) {
2368 ret
= grow_refcount_table(bs
, refcount_table_index
+ 1);
2372 refcount_block_offset
= s
->refcount_table
[refcount_table_index
];
2373 if (!refcount_block_offset
) {
2376 /* create a new refcount block */
2377 /* Note: we cannot update the refcount now to avoid recursion */
2378 offset
= alloc_clusters_noref(bs
, s
->cluster_size
);
2379 memset(s
->refcount_block_cache
, 0, s
->cluster_size
);
2380 ret
= bdrv_pwrite(s
->hd
, offset
, s
->refcount_block_cache
, s
->cluster_size
);
2381 if (ret
!= s
->cluster_size
)
2383 s
->refcount_table
[refcount_table_index
] = offset
;
2384 data64
= cpu_to_be64(offset
);
2385 ret
= bdrv_pwrite(s
->hd
, s
->refcount_table_offset
+
2386 refcount_table_index
* sizeof(uint64_t),
2387 &data64
, sizeof(data64
));
2388 if (ret
!= sizeof(data64
))
2391 refcount_block_offset
= offset
;
2392 s
->refcount_block_cache_offset
= offset
;
2393 update_refcount(bs
, offset
, s
->cluster_size
, 1);
2395 if (refcount_block_offset
!= s
->refcount_block_cache_offset
) {
2396 if (load_refcount_block(bs
, refcount_block_offset
) < 0)
2400 /* we can update the count and save it */
2401 block_index
= cluster_index
&
2402 ((1 << (s
->cluster_bits
- REFCOUNT_SHIFT
)) - 1);
2403 refcount
= be16_to_cpu(s
->refcount_block_cache
[block_index
]);
2405 if (refcount
< 0 || refcount
> 0xffff)
2407 if (refcount
== 0 && cluster_index
< s
->free_cluster_index
) {
2408 s
->free_cluster_index
= cluster_index
;
2410 s
->refcount_block_cache
[block_index
] = cpu_to_be16(refcount
);
2411 if (bdrv_pwrite(s
->hd
,
2412 refcount_block_offset
+ (block_index
<< REFCOUNT_SHIFT
),
2413 &s
->refcount_block_cache
[block_index
], 2) != 2)
2418 static void update_refcount(BlockDriverState
*bs
,
2419 int64_t offset
, int64_t length
,
2422 BDRVQcowState
*s
= bs
->opaque
;
2423 int64_t start
, last
, cluster_offset
;
2426 printf("update_refcount: offset=%lld size=%lld addend=%d\n",
2427 offset
, length
, addend
);
2431 start
= offset
& ~(s
->cluster_size
- 1);
2432 last
= (offset
+ length
- 1) & ~(s
->cluster_size
- 1);
2433 for(cluster_offset
= start
; cluster_offset
<= last
;
2434 cluster_offset
+= s
->cluster_size
) {
2435 update_cluster_refcount(bs
, cluster_offset
>> s
->cluster_bits
, addend
);
2440 static void inc_refcounts(BlockDriverState
*bs
,
2441 uint16_t *refcount_table
,
2442 int refcount_table_size
,
2443 int64_t offset
, int64_t size
)
2445 BDRVQcowState
*s
= bs
->opaque
;
2446 int64_t start
, last
, cluster_offset
;
2452 start
= offset
& ~(s
->cluster_size
- 1);
2453 last
= (offset
+ size
- 1) & ~(s
->cluster_size
- 1);
2454 for(cluster_offset
= start
; cluster_offset
<= last
;
2455 cluster_offset
+= s
->cluster_size
) {
2456 k
= cluster_offset
>> s
->cluster_bits
;
2457 if (k
< 0 || k
>= refcount_table_size
) {
2458 printf("ERROR: invalid cluster offset=0x%llx\n", cluster_offset
);
2460 if (++refcount_table
[k
] == 0) {
2461 printf("ERROR: overflow cluster offset=0x%llx\n", cluster_offset
);
2467 static int check_refcounts_l1(BlockDriverState
*bs
,
2468 uint16_t *refcount_table
,
2469 int refcount_table_size
,
2470 int64_t l1_table_offset
, int l1_size
,
2473 BDRVQcowState
*s
= bs
->opaque
;
2474 uint64_t *l1_table
, *l2_table
, l2_offset
, offset
, l1_size2
;
2475 int l2_size
, i
, j
, nb_csectors
, refcount
;
2478 l1_size2
= l1_size
* sizeof(uint64_t);
2480 inc_refcounts(bs
, refcount_table
, refcount_table_size
,
2481 l1_table_offset
, l1_size2
);
2483 l1_table
= qemu_malloc(l1_size2
);
2486 if (bdrv_pread(s
->hd
, l1_table_offset
,
2487 l1_table
, l1_size2
) != l1_size2
)
2489 for(i
= 0;i
< l1_size
; i
++)
2490 be64_to_cpus(&l1_table
[i
]);
2492 l2_size
= s
->l2_size
* sizeof(uint64_t);
2493 l2_table
= qemu_malloc(l2_size
);
2496 for(i
= 0; i
< l1_size
; i
++) {
2497 l2_offset
= l1_table
[i
];
2500 refcount
= get_refcount(bs
, (l2_offset
& ~QCOW_OFLAG_COPIED
) >> s
->cluster_bits
);
2501 if ((refcount
== 1) != ((l2_offset
& QCOW_OFLAG_COPIED
) != 0)) {
2502 printf("ERROR OFLAG_COPIED: l2_offset=%llx refcount=%d\n",
2503 l2_offset
, refcount
);
2506 l2_offset
&= ~QCOW_OFLAG_COPIED
;
2507 if (bdrv_pread(s
->hd
, l2_offset
, l2_table
, l2_size
) != l2_size
)
2509 for(j
= 0; j
< s
->l2_size
; j
++) {
2510 offset
= be64_to_cpu(l2_table
[j
]);
2512 if (offset
& QCOW_OFLAG_COMPRESSED
) {
2513 if (offset
& QCOW_OFLAG_COPIED
) {
2514 printf("ERROR: cluster %lld: copied flag must never be set for compressed clusters\n",
2515 offset
>> s
->cluster_bits
);
2516 offset
&= ~QCOW_OFLAG_COPIED
;
2518 nb_csectors
= ((offset
>> s
->csize_shift
) &
2520 offset
&= s
->cluster_offset_mask
;
2521 inc_refcounts(bs
, refcount_table
,
2522 refcount_table_size
,
2523 offset
& ~511, nb_csectors
* 512);
2526 refcount
= get_refcount(bs
, (offset
& ~QCOW_OFLAG_COPIED
) >> s
->cluster_bits
);
2527 if ((refcount
== 1) != ((offset
& QCOW_OFLAG_COPIED
) != 0)) {
2528 printf("ERROR OFLAG_COPIED: offset=%llx refcount=%d\n",
2532 offset
&= ~QCOW_OFLAG_COPIED
;
2533 inc_refcounts(bs
, refcount_table
,
2534 refcount_table_size
,
2535 offset
, s
->cluster_size
);
2539 inc_refcounts(bs
, refcount_table
,
2540 refcount_table_size
,
2545 qemu_free(l1_table
);
2546 qemu_free(l2_table
);
2549 printf("ERROR: I/O error in check_refcounts_l1\n");
2550 qemu_free(l1_table
);
2551 qemu_free(l2_table
);
2555 static void check_refcounts(BlockDriverState
*bs
)
2557 BDRVQcowState
*s
= bs
->opaque
;
2559 int nb_clusters
, refcount1
, refcount2
, i
;
2561 uint16_t *refcount_table
;
2563 size
= bdrv_getlength(s
->hd
);
2564 nb_clusters
= size_to_clusters(s
, size
);
2565 refcount_table
= qemu_mallocz(nb_clusters
* sizeof(uint16_t));
2568 inc_refcounts(bs
, refcount_table
, nb_clusters
,
2569 0, s
->cluster_size
);
2571 check_refcounts_l1(bs
, refcount_table
, nb_clusters
,
2572 s
->l1_table_offset
, s
->l1_size
, 1);
2575 for(i
= 0; i
< s
->nb_snapshots
; i
++) {
2576 sn
= s
->snapshots
+ i
;
2577 check_refcounts_l1(bs
, refcount_table
, nb_clusters
,
2578 sn
->l1_table_offset
, sn
->l1_size
, 0);
2580 inc_refcounts(bs
, refcount_table
, nb_clusters
,
2581 s
->snapshots_offset
, s
->snapshots_size
);
2584 inc_refcounts(bs
, refcount_table
, nb_clusters
,
2585 s
->refcount_table_offset
,
2586 s
->refcount_table_size
* sizeof(uint64_t));
2587 for(i
= 0; i
< s
->refcount_table_size
; i
++) {
2589 offset
= s
->refcount_table
[i
];
2591 inc_refcounts(bs
, refcount_table
, nb_clusters
,
2592 offset
, s
->cluster_size
);
2596 /* compare ref counts */
2597 for(i
= 0; i
< nb_clusters
; i
++) {
2598 refcount1
= get_refcount(bs
, i
);
2599 refcount2
= refcount_table
[i
];
2600 if (refcount1
!= refcount2
)
2601 printf("ERROR cluster %d refcount=%d reference=%d\n",
2602 i
, refcount1
, refcount2
);
2605 qemu_free(refcount_table
);
2609 static void dump_refcounts(BlockDriverState
*bs
)
2611 BDRVQcowState
*s
= bs
->opaque
;
2612 int64_t nb_clusters
, k
, k1
, size
;
2615 size
= bdrv_getlength(s
->hd
);
2616 nb_clusters
= size_to_clusters(s
, size
);
2617 for(k
= 0; k
< nb_clusters
;) {
2619 refcount
= get_refcount(bs
, k
);
2621 while (k
< nb_clusters
&& get_refcount(bs
, k
) == refcount
)
2623 printf("%lld: refcount=%d nb=%lld\n", k
, refcount
, k
- k1
);
2629 BlockDriver bdrv_qcow2
= {
2631 sizeof(BDRVQcowState
),
2643 .bdrv_aio_read
= qcow_aio_read
,
2644 .bdrv_aio_write
= qcow_aio_write
,
2645 .bdrv_aio_cancel
= qcow_aio_cancel
,
2646 .aiocb_size
= sizeof(QCowAIOCB
),
2647 .bdrv_write_compressed
= qcow_write_compressed
,
2649 .bdrv_snapshot_create
= qcow_snapshot_create
,
2650 .bdrv_snapshot_goto
= qcow_snapshot_goto
,
2651 .bdrv_snapshot_delete
= qcow_snapshot_delete
,
2652 .bdrv_snapshot_list
= qcow_snapshot_list
,
2653 .bdrv_get_info
= qcow_get_info
,