]>
Commit | Line | Data |
---|---|---|
f7d0fe02 KW |
1 | /* |
2 | * Block driver for the QCOW version 2 format | |
3 | * | |
4 | * Copyright (c) 2004-2006 Fabrice Bellard | |
5 | * | |
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: | |
12 | * | |
13 | * The above copyright notice and this permission notice shall be included in | |
14 | * all copies or substantial portions of the Software. | |
15 | * | |
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 | |
22 | * THE SOFTWARE. | |
23 | */ | |
24 | ||
25 | #ifndef BLOCK_QCOW2_H | |
26 | #define BLOCK_QCOW2_H | |
27 | ||
28 | #include "aes.h" | |
68d100e9 | 29 | #include "qemu-coroutine.h" |
f7d0fe02 | 30 | |
14899cdf FN |
31 | //#define DEBUG_ALLOC |
32 | //#define DEBUG_ALLOC2 | |
33 | //#define DEBUG_EXT | |
34 | ||
f7d0fe02 | 35 | #define QCOW_MAGIC (('Q' << 24) | ('F' << 16) | ('I' << 8) | 0xfb) |
f7d0fe02 KW |
36 | |
37 | #define QCOW_CRYPT_NONE 0 | |
38 | #define QCOW_CRYPT_AES 1 | |
39 | ||
40 | #define QCOW_MAX_CRYPT_CLUSTERS 32 | |
41 | ||
42 | /* indicate that the refcount of the referenced cluster is exactly one. */ | |
43 | #define QCOW_OFLAG_COPIED (1LL << 63) | |
44 | /* indicate that the cluster is compressed (they never have the copied flag) */ | |
45 | #define QCOW_OFLAG_COMPRESSED (1LL << 62) | |
6377af48 KW |
46 | /* The cluster reads as all zeros */ |
47 | #define QCOW_OFLAG_ZERO (1LL << 0) | |
f7d0fe02 KW |
48 | |
49 | #define REFCOUNT_SHIFT 1 /* refcount size is 2 bytes */ | |
50 | ||
51 | #define MIN_CLUSTER_BITS 9 | |
80ee15a6 | 52 | #define MAX_CLUSTER_BITS 21 |
f7d0fe02 KW |
53 | |
54 | #define L2_CACHE_SIZE 16 | |
55 | ||
29c1a730 KW |
56 | /* Must be at least 4 to cover all cases of refcount table growth */ |
57 | #define REFCOUNT_CACHE_SIZE 4 | |
58 | ||
99cce9fa KW |
59 | #define DEFAULT_CLUSTER_SIZE 65536 |
60 | ||
f7d0fe02 KW |
61 | typedef struct QCowHeader { |
62 | uint32_t magic; | |
63 | uint32_t version; | |
64 | uint64_t backing_file_offset; | |
65 | uint32_t backing_file_size; | |
66 | uint32_t cluster_bits; | |
67 | uint64_t size; /* in bytes */ | |
68 | uint32_t crypt_method; | |
69 | uint32_t l1_size; /* XXX: save number of clusters instead ? */ | |
70 | uint64_t l1_table_offset; | |
71 | uint64_t refcount_table_offset; | |
72 | uint32_t refcount_table_clusters; | |
73 | uint32_t nb_snapshots; | |
74 | uint64_t snapshots_offset; | |
6744cbab KW |
75 | |
76 | /* The following fields are only valid for version >= 3 */ | |
77 | uint64_t incompatible_features; | |
78 | uint64_t compatible_features; | |
79 | uint64_t autoclear_features; | |
80 | ||
81 | uint32_t refcount_order; | |
82 | uint32_t header_length; | |
f7d0fe02 KW |
83 | } QCowHeader; |
84 | ||
85 | typedef struct QCowSnapshot { | |
86 | uint64_t l1_table_offset; | |
87 | uint32_t l1_size; | |
88 | char *id_str; | |
89 | char *name; | |
90b27759 | 90 | uint64_t disk_size; |
c2c9a466 | 91 | uint64_t vm_state_size; |
f7d0fe02 KW |
92 | uint32_t date_sec; |
93 | uint32_t date_nsec; | |
94 | uint64_t vm_clock_nsec; | |
95 | } QCowSnapshot; | |
96 | ||
49381094 KW |
97 | struct Qcow2Cache; |
98 | typedef struct Qcow2Cache Qcow2Cache; | |
99 | ||
75bab85c KW |
100 | typedef struct Qcow2UnknownHeaderExtension { |
101 | uint32_t magic; | |
102 | uint32_t len; | |
103 | QLIST_ENTRY(Qcow2UnknownHeaderExtension) next; | |
104 | uint8_t data[]; | |
105 | } Qcow2UnknownHeaderExtension; | |
106 | ||
cfcc4c62 KW |
107 | enum { |
108 | QCOW2_FEAT_TYPE_INCOMPATIBLE = 0, | |
109 | QCOW2_FEAT_TYPE_COMPATIBLE = 1, | |
110 | QCOW2_FEAT_TYPE_AUTOCLEAR = 2, | |
111 | }; | |
112 | ||
c61d0004 SH |
113 | /* Incompatible feature bits */ |
114 | enum { | |
115 | QCOW2_INCOMPAT_DIRTY_BITNR = 0, | |
116 | QCOW2_INCOMPAT_DIRTY = 1 << QCOW2_INCOMPAT_DIRTY_BITNR, | |
117 | ||
118 | QCOW2_INCOMPAT_MASK = QCOW2_INCOMPAT_DIRTY, | |
119 | }; | |
120 | ||
bfe8043e SH |
121 | /* Compatible feature bits */ |
122 | enum { | |
123 | QCOW2_COMPAT_LAZY_REFCOUNTS_BITNR = 0, | |
124 | QCOW2_COMPAT_LAZY_REFCOUNTS = 1 << QCOW2_COMPAT_LAZY_REFCOUNTS_BITNR, | |
125 | ||
126 | QCOW2_COMPAT_FEAT_MASK = QCOW2_COMPAT_LAZY_REFCOUNTS, | |
127 | }; | |
128 | ||
cfcc4c62 KW |
129 | typedef struct Qcow2Feature { |
130 | uint8_t type; | |
131 | uint8_t bit; | |
132 | char name[46]; | |
133 | } QEMU_PACKED Qcow2Feature; | |
134 | ||
f7d0fe02 | 135 | typedef struct BDRVQcowState { |
f7d0fe02 KW |
136 | int cluster_bits; |
137 | int cluster_size; | |
138 | int cluster_sectors; | |
139 | int l2_bits; | |
140 | int l2_size; | |
141 | int l1_size; | |
142 | int l1_vm_state_index; | |
143 | int csize_shift; | |
144 | int csize_mask; | |
145 | uint64_t cluster_offset_mask; | |
146 | uint64_t l1_table_offset; | |
147 | uint64_t *l1_table; | |
29c1a730 KW |
148 | |
149 | Qcow2Cache* l2_table_cache; | |
150 | Qcow2Cache* refcount_block_cache; | |
151 | ||
f7d0fe02 KW |
152 | uint8_t *cluster_cache; |
153 | uint8_t *cluster_data; | |
154 | uint64_t cluster_cache_offset; | |
72cf2d4f | 155 | QLIST_HEAD(QCowClusterAlloc, QCowL2Meta) cluster_allocs; |
f7d0fe02 KW |
156 | |
157 | uint64_t *refcount_table; | |
158 | uint64_t refcount_table_offset; | |
159 | uint32_t refcount_table_size; | |
f7d0fe02 KW |
160 | int64_t free_cluster_index; |
161 | int64_t free_byte_offset; | |
162 | ||
68d100e9 KW |
163 | CoMutex lock; |
164 | ||
f7d0fe02 KW |
165 | uint32_t crypt_method; /* current crypt method, 0 if no key yet */ |
166 | uint32_t crypt_method_header; | |
167 | AES_KEY aes_encrypt_key; | |
168 | AES_KEY aes_decrypt_key; | |
169 | uint64_t snapshots_offset; | |
170 | int snapshots_size; | |
171 | int nb_snapshots; | |
172 | QCowSnapshot *snapshots; | |
06d9260f AL |
173 | |
174 | int flags; | |
6744cbab KW |
175 | int qcow_version; |
176 | ||
177 | uint64_t incompatible_features; | |
178 | uint64_t compatible_features; | |
179 | uint64_t autoclear_features; | |
180 | ||
181 | size_t unknown_header_fields_size; | |
182 | void* unknown_header_fields; | |
75bab85c | 183 | QLIST_HEAD(, Qcow2UnknownHeaderExtension) unknown_header_ext; |
f7d0fe02 KW |
184 | } BDRVQcowState; |
185 | ||
186 | /* XXX: use std qcow open function ? */ | |
187 | typedef struct QCowCreateState { | |
188 | int cluster_size; | |
189 | int cluster_bits; | |
190 | uint16_t *refcount_block; | |
191 | uint64_t *refcount_table; | |
192 | int64_t l1_table_offset; | |
193 | int64_t refcount_table_offset; | |
194 | int64_t refcount_block_offset; | |
195 | } QCowCreateState; | |
196 | ||
f214978a KW |
197 | struct QCowAIOCB; |
198 | ||
45aba42f KW |
199 | /* XXX This could be private for qcow2-cluster.c */ |
200 | typedef struct QCowL2Meta | |
201 | { | |
1d3afd64 | 202 | /** Guest offset of the first newly allocated cluster */ |
45aba42f | 203 | uint64_t offset; |
1d3afd64 KW |
204 | |
205 | /** Host offset of the first cluster of the request */ | |
148da7ea | 206 | uint64_t cluster_offset; |
1d3afd64 KW |
207 | |
208 | /** Host offset of the first newly allocated cluster */ | |
250196f1 | 209 | uint64_t alloc_offset; |
1d3afd64 KW |
210 | |
211 | /** | |
212 | * Number of sectors between the start of the first allocated cluster and | |
213 | * the area that the guest actually writes to. | |
214 | */ | |
45aba42f | 215 | int n_start; |
1d3afd64 KW |
216 | |
217 | /** | |
218 | * Number of sectors from the start of the first allocated cluster to | |
219 | * the end of the (possibly shortened) request | |
220 | */ | |
45aba42f | 221 | int nb_available; |
1d3afd64 KW |
222 | |
223 | /** Number of newly allocated clusters */ | |
45aba42f | 224 | int nb_clusters; |
1d3afd64 KW |
225 | |
226 | /** | |
227 | * Requests that overlap with this allocation and wait to be restarted | |
228 | * when the allocating request has completed. | |
229 | */ | |
68d100e9 | 230 | CoQueue dependent_requests; |
f214978a | 231 | |
72cf2d4f | 232 | QLIST_ENTRY(QCowL2Meta) next_in_flight; |
45aba42f KW |
233 | } QCowL2Meta; |
234 | ||
68d000a3 KW |
235 | enum { |
236 | QCOW2_CLUSTER_UNALLOCATED, | |
237 | QCOW2_CLUSTER_NORMAL, | |
238 | QCOW2_CLUSTER_COMPRESSED, | |
6377af48 | 239 | QCOW2_CLUSTER_ZERO |
68d000a3 KW |
240 | }; |
241 | ||
242 | #define L1E_OFFSET_MASK 0x00ffffffffffff00ULL | |
243 | #define L2E_OFFSET_MASK 0x00ffffffffffff00ULL | |
244 | #define L2E_COMPRESSED_OFFSET_SIZE_MASK 0x3fffffffffffffffULL | |
245 | ||
76dc9e0c KW |
246 | #define REFT_OFFSET_MASK 0xffffffffffffff00ULL |
247 | ||
45aba42f | 248 | static inline int size_to_clusters(BDRVQcowState *s, int64_t size) |
f7d0fe02 KW |
249 | { |
250 | return (size + (s->cluster_size - 1)) >> s->cluster_bits; | |
251 | } | |
252 | ||
419b19d9 SH |
253 | static inline int size_to_l1(BDRVQcowState *s, int64_t size) |
254 | { | |
255 | int shift = s->cluster_bits + s->l2_bits; | |
256 | return (size + (1ULL << shift) - 1) >> shift; | |
257 | } | |
258 | ||
c142442b KW |
259 | static inline int64_t align_offset(int64_t offset, int n) |
260 | { | |
261 | offset = (offset + n - 1) & ~(n - 1); | |
262 | return offset; | |
263 | } | |
264 | ||
68d000a3 KW |
265 | static inline int qcow2_get_cluster_type(uint64_t l2_entry) |
266 | { | |
267 | if (l2_entry & QCOW_OFLAG_COMPRESSED) { | |
268 | return QCOW2_CLUSTER_COMPRESSED; | |
6377af48 KW |
269 | } else if (l2_entry & QCOW_OFLAG_ZERO) { |
270 | return QCOW2_CLUSTER_ZERO; | |
68d000a3 KW |
271 | } else if (!(l2_entry & L2E_OFFSET_MASK)) { |
272 | return QCOW2_CLUSTER_UNALLOCATED; | |
273 | } else { | |
274 | return QCOW2_CLUSTER_NORMAL; | |
275 | } | |
276 | } | |
277 | ||
bfe8043e SH |
278 | /* Check whether refcounts are eager or lazy */ |
279 | static inline bool qcow2_need_accurate_refcounts(BDRVQcowState *s) | |
280 | { | |
281 | return !(s->incompatible_features & QCOW2_INCOMPAT_DIRTY); | |
282 | } | |
c142442b | 283 | |
f7d0fe02 KW |
284 | // FIXME Need qcow2_ prefix to global functions |
285 | ||
286 | /* qcow2.c functions */ | |
bd28f835 KW |
287 | int qcow2_backing_read1(BlockDriverState *bs, QEMUIOVector *qiov, |
288 | int64_t sector_num, int nb_sectors); | |
e24e49e6 | 289 | int qcow2_update_header(BlockDriverState *bs); |
f7d0fe02 KW |
290 | |
291 | /* qcow2-refcount.c functions */ | |
ed6ccf0f KW |
292 | int qcow2_refcount_init(BlockDriverState *bs); |
293 | void qcow2_refcount_close(BlockDriverState *bs); | |
f7d0fe02 | 294 | |
ed6ccf0f | 295 | int64_t qcow2_alloc_clusters(BlockDriverState *bs, int64_t size); |
256900b1 KW |
296 | int qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offset, |
297 | int nb_clusters); | |
ed6ccf0f KW |
298 | int64_t qcow2_alloc_bytes(BlockDriverState *bs, int size); |
299 | void qcow2_free_clusters(BlockDriverState *bs, | |
45aba42f | 300 | int64_t offset, int64_t size); |
ed6ccf0f | 301 | void qcow2_free_any_clusters(BlockDriverState *bs, |
45aba42f | 302 | uint64_t cluster_offset, int nb_clusters); |
f7d0fe02 | 303 | |
ed6ccf0f KW |
304 | int qcow2_update_snapshot_refcount(BlockDriverState *bs, |
305 | int64_t l1_table_offset, int l1_size, int addend); | |
f7d0fe02 | 306 | |
166acf54 KW |
307 | int qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res, |
308 | BdrvCheckMode fix); | |
f7d0fe02 | 309 | |
45aba42f | 310 | /* qcow2-cluster.c functions */ |
72893756 | 311 | int qcow2_grow_l1_table(BlockDriverState *bs, int min_size, bool exact_size); |
ed6ccf0f | 312 | void qcow2_l2_cache_reset(BlockDriverState *bs); |
66f82cee | 313 | int qcow2_decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset); |
ed6ccf0f | 314 | void qcow2_encrypt_sectors(BDRVQcowState *s, int64_t sector_num, |
45aba42f KW |
315 | uint8_t *out_buf, const uint8_t *in_buf, |
316 | int nb_sectors, int enc, | |
317 | const AES_KEY *key); | |
318 | ||
1c46efaa KW |
319 | int qcow2_get_cluster_offset(BlockDriverState *bs, uint64_t offset, |
320 | int *num, uint64_t *cluster_offset); | |
f4f0d391 KW |
321 | int qcow2_alloc_cluster_offset(BlockDriverState *bs, uint64_t offset, |
322 | int n_start, int n_end, int *num, QCowL2Meta *m); | |
ed6ccf0f | 323 | uint64_t qcow2_alloc_compressed_cluster_offset(BlockDriverState *bs, |
45aba42f KW |
324 | uint64_t offset, |
325 | int compressed_size); | |
326 | ||
148da7ea | 327 | int qcow2_alloc_cluster_link_l2(BlockDriverState *bs, QCowL2Meta *m); |
5ea929e3 KW |
328 | int qcow2_discard_clusters(BlockDriverState *bs, uint64_t offset, |
329 | int nb_sectors); | |
621f0589 | 330 | int qcow2_zero_clusters(BlockDriverState *bs, uint64_t offset, int nb_sectors); |
45aba42f | 331 | |
c142442b | 332 | /* qcow2-snapshot.c functions */ |
ed6ccf0f KW |
333 | int qcow2_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info); |
334 | int qcow2_snapshot_goto(BlockDriverState *bs, const char *snapshot_id); | |
335 | int qcow2_snapshot_delete(BlockDriverState *bs, const char *snapshot_id); | |
336 | int qcow2_snapshot_list(BlockDriverState *bs, QEMUSnapshotInfo **psn_tab); | |
51ef6727 | 337 | int qcow2_snapshot_load_tmp(BlockDriverState *bs, const char *snapshot_name); |
c142442b | 338 | |
ed6ccf0f KW |
339 | void qcow2_free_snapshots(BlockDriverState *bs); |
340 | int qcow2_read_snapshots(BlockDriverState *bs); | |
c142442b | 341 | |
49381094 | 342 | /* qcow2-cache.c functions */ |
6af4e9ea | 343 | Qcow2Cache *qcow2_cache_create(BlockDriverState *bs, int num_tables); |
49381094 KW |
344 | int qcow2_cache_destroy(BlockDriverState* bs, Qcow2Cache *c); |
345 | ||
346 | void qcow2_cache_entry_mark_dirty(Qcow2Cache *c, void *table); | |
347 | int qcow2_cache_flush(BlockDriverState *bs, Qcow2Cache *c); | |
348 | int qcow2_cache_set_dependency(BlockDriverState *bs, Qcow2Cache *c, | |
349 | Qcow2Cache *dependency); | |
3de0a294 | 350 | void qcow2_cache_depends_on_flush(Qcow2Cache *c); |
49381094 KW |
351 | |
352 | int qcow2_cache_get(BlockDriverState *bs, Qcow2Cache *c, uint64_t offset, | |
353 | void **table); | |
354 | int qcow2_cache_get_empty(BlockDriverState *bs, Qcow2Cache *c, uint64_t offset, | |
355 | void **table); | |
356 | int qcow2_cache_put(BlockDriverState *bs, Qcow2Cache *c, void **table); | |
357 | ||
f7d0fe02 | 358 | #endif |