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 "crypto/block.h" |
29 | #include "qemu/coroutine.h" |
30 | #include "qemu/units.h" |
31 | #include "block/block_int.h" |
32 | |
33 | //#define DEBUG_ALLOC |
34 | //#define DEBUG_ALLOC2 |
35 | //#define DEBUG_EXT |
36 | |
37 | #define QCOW_MAGIC (('Q' << 24) | ('F' << 16) | ('I' << 8) | 0xfb) |
38 | |
39 | #define QCOW_CRYPT_NONE 0 |
40 | #define QCOW_CRYPT_AES 1 |
41 | #define QCOW_CRYPT_LUKS 2 |
42 | |
43 | #define QCOW_MAX_CRYPT_CLUSTERS 32 |
44 | #define QCOW_MAX_SNAPSHOTS 65536 |
45 | |
46 | /* Field widths in qcow2 mean normal cluster offsets cannot reach |
47 | * 64PB; depending on cluster size, compressed clusters can have a |
48 | * smaller limit (64PB for up to 16k clusters, then ramps down to |
49 | * 512TB for 2M clusters). */ |
50 | #define QCOW_MAX_CLUSTER_OFFSET ((1ULL << 56) - 1) |
51 | |
52 | /* 8 MB refcount table is enough for 2 PB images at 64k cluster size |
53 | * (128 GB for 512 byte clusters, 2 EB for 2 MB clusters) */ |
54 | #define QCOW_MAX_REFTABLE_SIZE (8 * MiB) |
55 | |
56 | /* 32 MB L1 table is enough for 2 PB images at 64k cluster size |
57 | * (128 GB for 512 byte clusters, 2 EB for 2 MB clusters) */ |
58 | #define QCOW_MAX_L1_SIZE (32 * MiB) |
59 | |
60 | /* Allow for an average of 1k per snapshot table entry, should be plenty of |
61 | * space for snapshot names and IDs */ |
62 | #define QCOW_MAX_SNAPSHOTS_SIZE (1024 * QCOW_MAX_SNAPSHOTS) |
63 | |
64 | /* Bitmap header extension constraints */ |
65 | #define QCOW2_MAX_BITMAPS 65535 |
66 | #define QCOW2_MAX_BITMAP_DIRECTORY_SIZE (1024 * QCOW2_MAX_BITMAPS) |
67 | |
68 | /* indicate that the refcount of the referenced cluster is exactly one. */ |
69 | #define QCOW_OFLAG_COPIED (1ULL << 63) |
70 | /* indicate that the cluster is compressed (they never have the copied flag) */ |
71 | #define QCOW_OFLAG_COMPRESSED (1ULL << 62) |
72 | /* The cluster reads as all zeros */ |
73 | #define QCOW_OFLAG_ZERO (1ULL << 0) |
74 | |
75 | #define MIN_CLUSTER_BITS 9 |
76 | #define MAX_CLUSTER_BITS 21 |
77 | |
78 | /* Defined in the qcow2 spec (compressed cluster descriptor) */ |
79 | #define QCOW2_COMPRESSED_SECTOR_SIZE 512U |
80 | #define QCOW2_COMPRESSED_SECTOR_MASK (~(QCOW2_COMPRESSED_SECTOR_SIZE - 1)) |
81 | |
82 | /* Must be at least 2 to cover COW */ |
83 | #define MIN_L2_CACHE_SIZE 2 /* cache entries */ |
84 | |
85 | /* Must be at least 4 to cover all cases of refcount table growth */ |
86 | #define MIN_REFCOUNT_CACHE_SIZE 4 /* clusters */ |
87 | |
88 | #ifdef CONFIG_LINUX |
89 | #define DEFAULT_L2_CACHE_MAX_SIZE (32 * MiB) |
90 | #define DEFAULT_CACHE_CLEAN_INTERVAL 600 /* seconds */ |
91 | #else |
92 | #define DEFAULT_L2_CACHE_MAX_SIZE (8 * MiB) |
93 | /* Cache clean interval is currently available only on Linux, so must be 0 */ |
94 | #define DEFAULT_CACHE_CLEAN_INTERVAL 0 |
95 | #endif |
96 | |
97 | #define DEFAULT_CLUSTER_SIZE 65536 |
98 | |
99 | #define QCOW2_OPT_DATA_FILE "data-file" |
100 | #define QCOW2_OPT_LAZY_REFCOUNTS "lazy-refcounts" |
101 | #define QCOW2_OPT_DISCARD_REQUEST "pass-discard-request" |
102 | #define QCOW2_OPT_DISCARD_SNAPSHOT "pass-discard-snapshot" |
103 | #define QCOW2_OPT_DISCARD_OTHER "pass-discard-other" |
104 | #define QCOW2_OPT_OVERLAP "overlap-check" |
105 | #define QCOW2_OPT_OVERLAP_TEMPLATE "overlap-check.template" |
106 | #define QCOW2_OPT_OVERLAP_MAIN_HEADER "overlap-check.main-header" |
107 | #define QCOW2_OPT_OVERLAP_ACTIVE_L1 "overlap-check.active-l1" |
108 | #define QCOW2_OPT_OVERLAP_ACTIVE_L2 "overlap-check.active-l2" |
109 | #define QCOW2_OPT_OVERLAP_REFCOUNT_TABLE "overlap-check.refcount-table" |
110 | #define QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK "overlap-check.refcount-block" |
111 | #define QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE "overlap-check.snapshot-table" |
112 | #define QCOW2_OPT_OVERLAP_INACTIVE_L1 "overlap-check.inactive-l1" |
113 | #define QCOW2_OPT_OVERLAP_INACTIVE_L2 "overlap-check.inactive-l2" |
114 | #define QCOW2_OPT_OVERLAP_BITMAP_DIRECTORY "overlap-check.bitmap-directory" |
115 | #define QCOW2_OPT_CACHE_SIZE "cache-size" |
116 | #define QCOW2_OPT_L2_CACHE_SIZE "l2-cache-size" |
117 | #define QCOW2_OPT_L2_CACHE_ENTRY_SIZE "l2-cache-entry-size" |
118 | #define QCOW2_OPT_REFCOUNT_CACHE_SIZE "refcount-cache-size" |
119 | #define QCOW2_OPT_CACHE_CLEAN_INTERVAL "cache-clean-interval" |
120 | |
121 | typedef struct { |
122 | uint32_t ; |
123 | uint32_t ; |
124 | uint64_t ; |
125 | uint32_t ; |
126 | uint32_t ; |
127 | uint64_t ; /* in bytes */ |
128 | uint32_t ; |
129 | uint32_t ; /* XXX: save number of clusters instead ? */ |
130 | uint64_t ; |
131 | uint64_t ; |
132 | uint32_t ; |
133 | uint32_t ; |
134 | uint64_t ; |
135 | |
136 | /* The following fields are only valid for version >= 3 */ |
137 | uint64_t ; |
138 | uint64_t ; |
139 | uint64_t ; |
140 | |
141 | uint32_t ; |
142 | uint32_t ; |
143 | } QEMU_PACKED ; |
144 | |
145 | typedef struct QEMU_PACKED { |
146 | /* header is 8 byte aligned */ |
147 | uint64_t ; |
148 | |
149 | uint32_t ; |
150 | uint16_t ; |
151 | uint16_t ; |
152 | |
153 | uint32_t ; |
154 | uint32_t ; |
155 | |
156 | uint64_t ; |
157 | |
158 | uint32_t ; |
159 | uint32_t ; /* for extension */ |
160 | /* extra data follows */ |
161 | /* id_str follows */ |
162 | /* name follows */ |
163 | } ; |
164 | |
165 | typedef struct QEMU_PACKED { |
166 | uint64_t ; |
167 | uint64_t ; |
168 | } ; |
169 | |
170 | |
171 | typedef struct QCowSnapshot { |
172 | uint64_t l1_table_offset; |
173 | uint32_t l1_size; |
174 | char *id_str; |
175 | char *name; |
176 | uint64_t disk_size; |
177 | uint64_t vm_state_size; |
178 | uint32_t date_sec; |
179 | uint32_t date_nsec; |
180 | uint64_t vm_clock_nsec; |
181 | } QCowSnapshot; |
182 | |
183 | struct Qcow2Cache; |
184 | typedef struct Qcow2Cache Qcow2Cache; |
185 | |
186 | typedef struct { |
187 | uint64_t ; |
188 | uint64_t ; |
189 | } QEMU_PACKED ; |
190 | |
191 | typedef struct { |
192 | uint32_t ; |
193 | uint32_t ; |
194 | QLIST_ENTRY(Qcow2UnknownHeaderExtension) ; |
195 | uint8_t []; |
196 | } ; |
197 | |
198 | enum { |
199 | QCOW2_FEAT_TYPE_INCOMPATIBLE = 0, |
200 | QCOW2_FEAT_TYPE_COMPATIBLE = 1, |
201 | QCOW2_FEAT_TYPE_AUTOCLEAR = 2, |
202 | }; |
203 | |
204 | /* Incompatible feature bits */ |
205 | enum { |
206 | QCOW2_INCOMPAT_DIRTY_BITNR = 0, |
207 | QCOW2_INCOMPAT_CORRUPT_BITNR = 1, |
208 | QCOW2_INCOMPAT_DATA_FILE_BITNR = 2, |
209 | QCOW2_INCOMPAT_DIRTY = 1 << QCOW2_INCOMPAT_DIRTY_BITNR, |
210 | QCOW2_INCOMPAT_CORRUPT = 1 << QCOW2_INCOMPAT_CORRUPT_BITNR, |
211 | QCOW2_INCOMPAT_DATA_FILE = 1 << QCOW2_INCOMPAT_DATA_FILE_BITNR, |
212 | |
213 | QCOW2_INCOMPAT_MASK = QCOW2_INCOMPAT_DIRTY |
214 | | QCOW2_INCOMPAT_CORRUPT |
215 | | QCOW2_INCOMPAT_DATA_FILE, |
216 | }; |
217 | |
218 | /* Compatible feature bits */ |
219 | enum { |
220 | QCOW2_COMPAT_LAZY_REFCOUNTS_BITNR = 0, |
221 | QCOW2_COMPAT_LAZY_REFCOUNTS = 1 << QCOW2_COMPAT_LAZY_REFCOUNTS_BITNR, |
222 | |
223 | QCOW2_COMPAT_FEAT_MASK = QCOW2_COMPAT_LAZY_REFCOUNTS, |
224 | }; |
225 | |
226 | /* Autoclear feature bits */ |
227 | enum { |
228 | QCOW2_AUTOCLEAR_BITMAPS_BITNR = 0, |
229 | QCOW2_AUTOCLEAR_DATA_FILE_RAW_BITNR = 1, |
230 | QCOW2_AUTOCLEAR_BITMAPS = 1 << QCOW2_AUTOCLEAR_BITMAPS_BITNR, |
231 | QCOW2_AUTOCLEAR_DATA_FILE_RAW = 1 << QCOW2_AUTOCLEAR_DATA_FILE_RAW_BITNR, |
232 | |
233 | QCOW2_AUTOCLEAR_MASK = QCOW2_AUTOCLEAR_BITMAPS |
234 | | QCOW2_AUTOCLEAR_DATA_FILE_RAW, |
235 | }; |
236 | |
237 | enum qcow2_discard_type { |
238 | QCOW2_DISCARD_NEVER = 0, |
239 | QCOW2_DISCARD_ALWAYS, |
240 | QCOW2_DISCARD_REQUEST, |
241 | QCOW2_DISCARD_SNAPSHOT, |
242 | QCOW2_DISCARD_OTHER, |
243 | QCOW2_DISCARD_MAX |
244 | }; |
245 | |
246 | typedef struct Qcow2Feature { |
247 | uint8_t type; |
248 | uint8_t bit; |
249 | char name[46]; |
250 | } QEMU_PACKED Qcow2Feature; |
251 | |
252 | typedef struct Qcow2DiscardRegion { |
253 | BlockDriverState *bs; |
254 | uint64_t offset; |
255 | uint64_t bytes; |
256 | QTAILQ_ENTRY(Qcow2DiscardRegion) next; |
257 | } Qcow2DiscardRegion; |
258 | |
259 | typedef uint64_t Qcow2GetRefcountFunc(const void *refcount_array, |
260 | uint64_t index); |
261 | typedef void Qcow2SetRefcountFunc(void *refcount_array, |
262 | uint64_t index, uint64_t value); |
263 | |
264 | typedef struct { |
265 | uint32_t ; |
266 | uint32_t ; |
267 | uint64_t ; |
268 | uint64_t ; |
269 | } QEMU_PACKED ; |
270 | |
271 | #define QCOW2_MAX_THREADS 4 |
272 | |
273 | typedef struct BDRVQcow2State { |
274 | int cluster_bits; |
275 | int cluster_size; |
276 | int l2_slice_size; |
277 | int l2_bits; |
278 | int l2_size; |
279 | int l1_size; |
280 | int l1_vm_state_index; |
281 | int refcount_block_bits; |
282 | int refcount_block_size; |
283 | int csize_shift; |
284 | int csize_mask; |
285 | uint64_t cluster_offset_mask; |
286 | uint64_t l1_table_offset; |
287 | uint64_t *l1_table; |
288 | |
289 | Qcow2Cache* l2_table_cache; |
290 | Qcow2Cache* refcount_block_cache; |
291 | QEMUTimer *cache_clean_timer; |
292 | unsigned cache_clean_interval; |
293 | |
294 | uint8_t *cluster_cache; |
295 | uint8_t *cluster_data; |
296 | uint64_t cluster_cache_offset; |
297 | QLIST_HEAD(, QCowL2Meta) cluster_allocs; |
298 | |
299 | uint64_t *refcount_table; |
300 | uint64_t refcount_table_offset; |
301 | uint32_t refcount_table_size; |
302 | uint32_t max_refcount_table_index; /* Last used entry in refcount_table */ |
303 | uint64_t free_cluster_index; |
304 | uint64_t free_byte_offset; |
305 | |
306 | CoMutex lock; |
307 | |
308 | Qcow2CryptoHeaderExtension ; /* QCow2 header extension */ |
309 | QCryptoBlockOpenOptions *crypto_opts; /* Disk encryption runtime options */ |
310 | QCryptoBlock *crypto; /* Disk encryption format driver */ |
311 | bool crypt_physical_offset; /* Whether to use virtual or physical offset |
312 | for encryption initialization vector tweak */ |
313 | uint32_t ; |
314 | uint64_t snapshots_offset; |
315 | int snapshots_size; |
316 | unsigned int nb_snapshots; |
317 | QCowSnapshot *snapshots; |
318 | |
319 | uint32_t nb_bitmaps; |
320 | uint64_t bitmap_directory_size; |
321 | uint64_t bitmap_directory_offset; |
322 | |
323 | int flags; |
324 | int qcow_version; |
325 | bool use_lazy_refcounts; |
326 | int refcount_order; |
327 | int refcount_bits; |
328 | uint64_t refcount_max; |
329 | |
330 | Qcow2GetRefcountFunc *get_refcount; |
331 | Qcow2SetRefcountFunc *set_refcount; |
332 | |
333 | bool discard_passthrough[QCOW2_DISCARD_MAX]; |
334 | |
335 | int overlap_check; /* bitmask of Qcow2MetadataOverlap values */ |
336 | bool signaled_corruption; |
337 | |
338 | uint64_t incompatible_features; |
339 | uint64_t compatible_features; |
340 | uint64_t autoclear_features; |
341 | |
342 | size_t ; |
343 | void* ; |
344 | QLIST_HEAD(, Qcow2UnknownHeaderExtension) ; |
345 | QTAILQ_HEAD (, Qcow2DiscardRegion) discards; |
346 | bool cache_discards; |
347 | |
348 | /* Backing file path and format as stored in the image (this is not the |
349 | * effective path/format, which may be the result of a runtime option |
350 | * override) */ |
351 | char *image_backing_file; |
352 | char *image_backing_format; |
353 | char *image_data_file; |
354 | |
355 | CoQueue thread_task_queue; |
356 | int nb_threads; |
357 | |
358 | BdrvChild *data_file; |
359 | |
360 | bool metadata_preallocation_checked; |
361 | bool metadata_preallocation; |
362 | } BDRVQcow2State; |
363 | |
364 | typedef struct Qcow2COWRegion { |
365 | /** |
366 | * Offset of the COW region in bytes from the start of the first cluster |
367 | * touched by the request. |
368 | */ |
369 | unsigned offset; |
370 | |
371 | /** Number of bytes to copy */ |
372 | unsigned nb_bytes; |
373 | } Qcow2COWRegion; |
374 | |
375 | /** |
376 | * Describes an in-flight (part of a) write request that writes to clusters |
377 | * that are not referenced in their L2 table yet. |
378 | */ |
379 | typedef struct QCowL2Meta |
380 | { |
381 | /** Guest offset of the first newly allocated cluster */ |
382 | uint64_t offset; |
383 | |
384 | /** Host offset of the first newly allocated cluster */ |
385 | uint64_t alloc_offset; |
386 | |
387 | /** Number of newly allocated clusters */ |
388 | int nb_clusters; |
389 | |
390 | /** Do not free the old clusters */ |
391 | bool keep_old_clusters; |
392 | |
393 | /** |
394 | * Requests that overlap with this allocation and wait to be restarted |
395 | * when the allocating request has completed. |
396 | */ |
397 | CoQueue dependent_requests; |
398 | |
399 | /** |
400 | * The COW Region between the start of the first allocated cluster and the |
401 | * area the guest actually writes to. |
402 | */ |
403 | Qcow2COWRegion cow_start; |
404 | |
405 | /** |
406 | * The COW Region between the area the guest actually writes to and the |
407 | * end of the last allocated cluster. |
408 | */ |
409 | Qcow2COWRegion cow_end; |
410 | |
411 | /* |
412 | * Indicates that COW regions are already handled and do not require |
413 | * any more processing. |
414 | */ |
415 | bool skip_cow; |
416 | |
417 | /** |
418 | * The I/O vector with the data from the actual guest write request. |
419 | * If non-NULL, this is meant to be merged together with the data |
420 | * from @cow_start and @cow_end into one single write operation. |
421 | */ |
422 | QEMUIOVector *data_qiov; |
423 | size_t data_qiov_offset; |
424 | |
425 | /** Pointer to next L2Meta of the same write request */ |
426 | struct QCowL2Meta *next; |
427 | |
428 | QLIST_ENTRY(QCowL2Meta) next_in_flight; |
429 | } QCowL2Meta; |
430 | |
431 | typedef enum QCow2ClusterType { |
432 | QCOW2_CLUSTER_UNALLOCATED, |
433 | QCOW2_CLUSTER_ZERO_PLAIN, |
434 | QCOW2_CLUSTER_ZERO_ALLOC, |
435 | QCOW2_CLUSTER_NORMAL, |
436 | QCOW2_CLUSTER_COMPRESSED, |
437 | } QCow2ClusterType; |
438 | |
439 | typedef enum QCow2MetadataOverlap { |
440 | QCOW2_OL_MAIN_HEADER_BITNR = 0, |
441 | QCOW2_OL_ACTIVE_L1_BITNR = 1, |
442 | QCOW2_OL_ACTIVE_L2_BITNR = 2, |
443 | QCOW2_OL_REFCOUNT_TABLE_BITNR = 3, |
444 | QCOW2_OL_REFCOUNT_BLOCK_BITNR = 4, |
445 | QCOW2_OL_SNAPSHOT_TABLE_BITNR = 5, |
446 | QCOW2_OL_INACTIVE_L1_BITNR = 6, |
447 | QCOW2_OL_INACTIVE_L2_BITNR = 7, |
448 | QCOW2_OL_BITMAP_DIRECTORY_BITNR = 8, |
449 | |
450 | QCOW2_OL_MAX_BITNR = 9, |
451 | |
452 | QCOW2_OL_NONE = 0, |
453 | QCOW2_OL_MAIN_HEADER = (1 << QCOW2_OL_MAIN_HEADER_BITNR), |
454 | QCOW2_OL_ACTIVE_L1 = (1 << QCOW2_OL_ACTIVE_L1_BITNR), |
455 | QCOW2_OL_ACTIVE_L2 = (1 << QCOW2_OL_ACTIVE_L2_BITNR), |
456 | QCOW2_OL_REFCOUNT_TABLE = (1 << QCOW2_OL_REFCOUNT_TABLE_BITNR), |
457 | QCOW2_OL_REFCOUNT_BLOCK = (1 << QCOW2_OL_REFCOUNT_BLOCK_BITNR), |
458 | QCOW2_OL_SNAPSHOT_TABLE = (1 << QCOW2_OL_SNAPSHOT_TABLE_BITNR), |
459 | QCOW2_OL_INACTIVE_L1 = (1 << QCOW2_OL_INACTIVE_L1_BITNR), |
460 | /* NOTE: Checking overlaps with inactive L2 tables will result in bdrv |
461 | * reads. */ |
462 | QCOW2_OL_INACTIVE_L2 = (1 << QCOW2_OL_INACTIVE_L2_BITNR), |
463 | QCOW2_OL_BITMAP_DIRECTORY = (1 << QCOW2_OL_BITMAP_DIRECTORY_BITNR), |
464 | } QCow2MetadataOverlap; |
465 | |
466 | /* Perform all overlap checks which can be done in constant time */ |
467 | #define QCOW2_OL_CONSTANT \ |
468 | (QCOW2_OL_MAIN_HEADER | QCOW2_OL_ACTIVE_L1 | QCOW2_OL_REFCOUNT_TABLE | \ |
469 | QCOW2_OL_SNAPSHOT_TABLE | QCOW2_OL_BITMAP_DIRECTORY) |
470 | |
471 | /* Perform all overlap checks which don't require disk access */ |
472 | #define QCOW2_OL_CACHED \ |
473 | (QCOW2_OL_CONSTANT | QCOW2_OL_ACTIVE_L2 | QCOW2_OL_REFCOUNT_BLOCK | \ |
474 | QCOW2_OL_INACTIVE_L1) |
475 | |
476 | /* Perform all overlap checks */ |
477 | #define QCOW2_OL_ALL \ |
478 | (QCOW2_OL_CACHED | QCOW2_OL_INACTIVE_L2) |
479 | |
480 | #define L1E_OFFSET_MASK 0x00fffffffffffe00ULL |
481 | #define L2E_OFFSET_MASK 0x00fffffffffffe00ULL |
482 | #define L2E_COMPRESSED_OFFSET_SIZE_MASK 0x3fffffffffffffffULL |
483 | |
484 | #define REFT_OFFSET_MASK 0xfffffffffffffe00ULL |
485 | |
486 | #define INV_OFFSET (-1ULL) |
487 | |
488 | static inline bool has_data_file(BlockDriverState *bs) |
489 | { |
490 | BDRVQcow2State *s = bs->opaque; |
491 | return (s->data_file != bs->file); |
492 | } |
493 | |
494 | static inline bool data_file_is_raw(BlockDriverState *bs) |
495 | { |
496 | BDRVQcow2State *s = bs->opaque; |
497 | return !!(s->autoclear_features & QCOW2_AUTOCLEAR_DATA_FILE_RAW); |
498 | } |
499 | |
500 | static inline int64_t start_of_cluster(BDRVQcow2State *s, int64_t offset) |
501 | { |
502 | return offset & ~(s->cluster_size - 1); |
503 | } |
504 | |
505 | static inline int64_t offset_into_cluster(BDRVQcow2State *s, int64_t offset) |
506 | { |
507 | return offset & (s->cluster_size - 1); |
508 | } |
509 | |
510 | static inline uint64_t size_to_clusters(BDRVQcow2State *s, uint64_t size) |
511 | { |
512 | return (size + (s->cluster_size - 1)) >> s->cluster_bits; |
513 | } |
514 | |
515 | static inline int64_t size_to_l1(BDRVQcow2State *s, int64_t size) |
516 | { |
517 | int shift = s->cluster_bits + s->l2_bits; |
518 | return (size + (1ULL << shift) - 1) >> shift; |
519 | } |
520 | |
521 | static inline int offset_to_l1_index(BDRVQcow2State *s, uint64_t offset) |
522 | { |
523 | return offset >> (s->l2_bits + s->cluster_bits); |
524 | } |
525 | |
526 | static inline int offset_to_l2_index(BDRVQcow2State *s, int64_t offset) |
527 | { |
528 | return (offset >> s->cluster_bits) & (s->l2_size - 1); |
529 | } |
530 | |
531 | static inline int offset_to_l2_slice_index(BDRVQcow2State *s, int64_t offset) |
532 | { |
533 | return (offset >> s->cluster_bits) & (s->l2_slice_size - 1); |
534 | } |
535 | |
536 | static inline int64_t qcow2_vm_state_offset(BDRVQcow2State *s) |
537 | { |
538 | return (int64_t)s->l1_vm_state_index << (s->cluster_bits + s->l2_bits); |
539 | } |
540 | |
541 | static inline QCow2ClusterType qcow2_get_cluster_type(BlockDriverState *bs, |
542 | uint64_t l2_entry) |
543 | { |
544 | if (l2_entry & QCOW_OFLAG_COMPRESSED) { |
545 | return QCOW2_CLUSTER_COMPRESSED; |
546 | } else if (l2_entry & QCOW_OFLAG_ZERO) { |
547 | if (l2_entry & L2E_OFFSET_MASK) { |
548 | return QCOW2_CLUSTER_ZERO_ALLOC; |
549 | } |
550 | return QCOW2_CLUSTER_ZERO_PLAIN; |
551 | } else if (!(l2_entry & L2E_OFFSET_MASK)) { |
552 | /* Offset 0 generally means unallocated, but it is ambiguous with |
553 | * external data files because 0 is a valid offset there. However, all |
554 | * clusters in external data files always have refcount 1, so we can |
555 | * rely on QCOW_OFLAG_COPIED to disambiguate. */ |
556 | if (has_data_file(bs) && (l2_entry & QCOW_OFLAG_COPIED)) { |
557 | return QCOW2_CLUSTER_NORMAL; |
558 | } else { |
559 | return QCOW2_CLUSTER_UNALLOCATED; |
560 | } |
561 | } else { |
562 | return QCOW2_CLUSTER_NORMAL; |
563 | } |
564 | } |
565 | |
566 | /* Check whether refcounts are eager or lazy */ |
567 | static inline bool qcow2_need_accurate_refcounts(BDRVQcow2State *s) |
568 | { |
569 | return !(s->incompatible_features & QCOW2_INCOMPAT_DIRTY); |
570 | } |
571 | |
572 | static inline uint64_t l2meta_cow_start(QCowL2Meta *m) |
573 | { |
574 | return m->offset + m->cow_start.offset; |
575 | } |
576 | |
577 | static inline uint64_t l2meta_cow_end(QCowL2Meta *m) |
578 | { |
579 | return m->offset + m->cow_end.offset + m->cow_end.nb_bytes; |
580 | } |
581 | |
582 | static inline uint64_t refcount_diff(uint64_t r1, uint64_t r2) |
583 | { |
584 | return r1 > r2 ? r1 - r2 : r2 - r1; |
585 | } |
586 | |
587 | static inline |
588 | uint32_t offset_to_reftable_index(BDRVQcow2State *s, uint64_t offset) |
589 | { |
590 | return offset >> (s->refcount_block_bits + s->cluster_bits); |
591 | } |
592 | |
593 | /* qcow2.c functions */ |
594 | int64_t qcow2_refcount_metadata_size(int64_t clusters, size_t cluster_size, |
595 | int refcount_order, bool generous_increase, |
596 | uint64_t *refblock_count); |
597 | |
598 | int qcow2_mark_dirty(BlockDriverState *bs); |
599 | int qcow2_mark_corrupt(BlockDriverState *bs); |
600 | int qcow2_mark_consistent(BlockDriverState *bs); |
601 | int (BlockDriverState *bs); |
602 | |
603 | void qcow2_signal_corruption(BlockDriverState *bs, bool fatal, int64_t offset, |
604 | int64_t size, const char *message_format, ...) |
605 | GCC_FMT_ATTR(5, 6); |
606 | |
607 | int qcow2_validate_table(BlockDriverState *bs, uint64_t offset, |
608 | uint64_t entries, size_t entry_len, |
609 | int64_t max_size_bytes, const char *table_name, |
610 | Error **errp); |
611 | |
612 | /* qcow2-refcount.c functions */ |
613 | int qcow2_refcount_init(BlockDriverState *bs); |
614 | void qcow2_refcount_close(BlockDriverState *bs); |
615 | |
616 | int qcow2_get_refcount(BlockDriverState *bs, int64_t cluster_index, |
617 | uint64_t *refcount); |
618 | |
619 | int qcow2_update_cluster_refcount(BlockDriverState *bs, int64_t cluster_index, |
620 | uint64_t addend, bool decrease, |
621 | enum qcow2_discard_type type); |
622 | |
623 | int64_t qcow2_refcount_area(BlockDriverState *bs, uint64_t offset, |
624 | uint64_t additional_clusters, bool exact_size, |
625 | int new_refblock_index, |
626 | uint64_t new_refblock_offset); |
627 | |
628 | int64_t qcow2_alloc_clusters(BlockDriverState *bs, uint64_t size); |
629 | int64_t qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offset, |
630 | int64_t nb_clusters); |
631 | int64_t qcow2_alloc_bytes(BlockDriverState *bs, int size); |
632 | void qcow2_free_clusters(BlockDriverState *bs, |
633 | int64_t offset, int64_t size, |
634 | enum qcow2_discard_type type); |
635 | void qcow2_free_any_clusters(BlockDriverState *bs, uint64_t l2_entry, |
636 | int nb_clusters, enum qcow2_discard_type type); |
637 | |
638 | int qcow2_update_snapshot_refcount(BlockDriverState *bs, |
639 | int64_t l1_table_offset, int l1_size, int addend); |
640 | |
641 | int coroutine_fn qcow2_flush_caches(BlockDriverState *bs); |
642 | int coroutine_fn qcow2_write_caches(BlockDriverState *bs); |
643 | int qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res, |
644 | BdrvCheckMode fix); |
645 | |
646 | void qcow2_process_discards(BlockDriverState *bs, int ret); |
647 | |
648 | int qcow2_check_metadata_overlap(BlockDriverState *bs, int ign, int64_t offset, |
649 | int64_t size); |
650 | int qcow2_pre_write_overlap_check(BlockDriverState *bs, int ign, int64_t offset, |
651 | int64_t size, bool data_file); |
652 | int qcow2_inc_refcounts_imrt(BlockDriverState *bs, BdrvCheckResult *res, |
653 | void **refcount_table, |
654 | int64_t *refcount_table_size, |
655 | int64_t offset, int64_t size); |
656 | |
657 | int qcow2_change_refcount_order(BlockDriverState *bs, int refcount_order, |
658 | BlockDriverAmendStatusCB *status_cb, |
659 | void *cb_opaque, Error **errp); |
660 | int qcow2_shrink_reftable(BlockDriverState *bs); |
661 | int64_t qcow2_get_last_cluster(BlockDriverState *bs, int64_t size); |
662 | int qcow2_detect_metadata_preallocation(BlockDriverState *bs); |
663 | |
664 | /* qcow2-cluster.c functions */ |
665 | int qcow2_grow_l1_table(BlockDriverState *bs, uint64_t min_size, |
666 | bool exact_size); |
667 | int qcow2_shrink_l1_table(BlockDriverState *bs, uint64_t max_size); |
668 | int qcow2_write_l1_entry(BlockDriverState *bs, int l1_index); |
669 | int qcow2_encrypt_sectors(BDRVQcow2State *s, int64_t sector_num, |
670 | uint8_t *buf, int nb_sectors, bool enc, Error **errp); |
671 | |
672 | int qcow2_get_cluster_offset(BlockDriverState *bs, uint64_t offset, |
673 | unsigned int *bytes, uint64_t *cluster_offset); |
674 | int qcow2_alloc_cluster_offset(BlockDriverState *bs, uint64_t offset, |
675 | unsigned int *bytes, uint64_t *host_offset, |
676 | QCowL2Meta **m); |
677 | int qcow2_alloc_compressed_cluster_offset(BlockDriverState *bs, |
678 | uint64_t offset, |
679 | int compressed_size, |
680 | uint64_t *host_offset); |
681 | |
682 | int qcow2_alloc_cluster_link_l2(BlockDriverState *bs, QCowL2Meta *m); |
683 | void qcow2_alloc_cluster_abort(BlockDriverState *bs, QCowL2Meta *m); |
684 | int qcow2_cluster_discard(BlockDriverState *bs, uint64_t offset, |
685 | uint64_t bytes, enum qcow2_discard_type type, |
686 | bool full_discard); |
687 | int qcow2_cluster_zeroize(BlockDriverState *bs, uint64_t offset, |
688 | uint64_t bytes, int flags); |
689 | |
690 | int qcow2_expand_zero_clusters(BlockDriverState *bs, |
691 | BlockDriverAmendStatusCB *status_cb, |
692 | void *cb_opaque); |
693 | |
694 | /* qcow2-snapshot.c functions */ |
695 | int qcow2_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info); |
696 | int qcow2_snapshot_goto(BlockDriverState *bs, const char *snapshot_id); |
697 | int qcow2_snapshot_delete(BlockDriverState *bs, |
698 | const char *snapshot_id, |
699 | const char *name, |
700 | Error **errp); |
701 | int qcow2_snapshot_list(BlockDriverState *bs, QEMUSnapshotInfo **psn_tab); |
702 | int qcow2_snapshot_load_tmp(BlockDriverState *bs, |
703 | const char *snapshot_id, |
704 | const char *name, |
705 | Error **errp); |
706 | |
707 | void qcow2_free_snapshots(BlockDriverState *bs); |
708 | int qcow2_read_snapshots(BlockDriverState *bs); |
709 | |
710 | /* qcow2-cache.c functions */ |
711 | Qcow2Cache *qcow2_cache_create(BlockDriverState *bs, int num_tables, |
712 | unsigned table_size); |
713 | int qcow2_cache_destroy(Qcow2Cache *c); |
714 | |
715 | void qcow2_cache_entry_mark_dirty(Qcow2Cache *c, void *table); |
716 | int qcow2_cache_flush(BlockDriverState *bs, Qcow2Cache *c); |
717 | int qcow2_cache_write(BlockDriverState *bs, Qcow2Cache *c); |
718 | int qcow2_cache_set_dependency(BlockDriverState *bs, Qcow2Cache *c, |
719 | Qcow2Cache *dependency); |
720 | void qcow2_cache_depends_on_flush(Qcow2Cache *c); |
721 | |
722 | void qcow2_cache_clean_unused(Qcow2Cache *c); |
723 | int qcow2_cache_empty(BlockDriverState *bs, Qcow2Cache *c); |
724 | |
725 | int qcow2_cache_get(BlockDriverState *bs, Qcow2Cache *c, uint64_t offset, |
726 | void **table); |
727 | int qcow2_cache_get_empty(BlockDriverState *bs, Qcow2Cache *c, uint64_t offset, |
728 | void **table); |
729 | void qcow2_cache_put(Qcow2Cache *c, void **table); |
730 | void *qcow2_cache_is_table_offset(Qcow2Cache *c, uint64_t offset); |
731 | void qcow2_cache_discard(Qcow2Cache *c, void *table); |
732 | |
733 | /* qcow2-bitmap.c functions */ |
734 | int qcow2_check_bitmaps_refcounts(BlockDriverState *bs, BdrvCheckResult *res, |
735 | void **refcount_table, |
736 | int64_t *refcount_table_size); |
737 | bool qcow2_load_dirty_bitmaps(BlockDriverState *bs, Error **errp); |
738 | Qcow2BitmapInfoList *qcow2_get_bitmap_info_list(BlockDriverState *bs, |
739 | Error **errp); |
740 | int qcow2_reopen_bitmaps_rw_hint(BlockDriverState *bs, bool *, |
741 | Error **errp); |
742 | int qcow2_reopen_bitmaps_rw(BlockDriverState *bs, Error **errp); |
743 | int qcow2_truncate_bitmaps_check(BlockDriverState *bs, Error **errp); |
744 | void qcow2_store_persistent_dirty_bitmaps(BlockDriverState *bs, Error **errp); |
745 | int qcow2_reopen_bitmaps_ro(BlockDriverState *bs, Error **errp); |
746 | bool qcow2_can_store_new_dirty_bitmap(BlockDriverState *bs, |
747 | const char *name, |
748 | uint32_t granularity, |
749 | Error **errp); |
750 | void qcow2_remove_persistent_dirty_bitmap(BlockDriverState *bs, |
751 | const char *name, |
752 | Error **errp); |
753 | |
754 | ssize_t coroutine_fn |
755 | qcow2_co_compress(BlockDriverState *bs, void *dest, size_t dest_size, |
756 | const void *src, size_t src_size); |
757 | ssize_t coroutine_fn |
758 | qcow2_co_decompress(BlockDriverState *bs, void *dest, size_t dest_size, |
759 | const void *src, size_t src_size); |
760 | int coroutine_fn |
761 | qcow2_co_encrypt(BlockDriverState *bs, uint64_t file_cluster_offset, |
762 | uint64_t offset, void *buf, size_t len); |
763 | int coroutine_fn |
764 | qcow2_co_decrypt(BlockDriverState *bs, uint64_t file_cluster_offset, |
765 | uint64_t offset, void *buf, size_t len); |
766 | |
767 | #endif |
768 | |