2 * Bitmaps for the QCOW version 2 format
4 * Copyright (c) 2014-2017 Vladimir Sementsov-Ogievskiy
6 * This file is derived from qcow2-snapshot.c, original copyright:
7 * Copyright (c) 2004-2006 Fabrice Bellard
9 * Permission is hereby granted, free of charge, to any person obtaining a copy
10 * of this software and associated documentation files (the "Software"), to deal
11 * in the Software without restriction, including without limitation the rights
12 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13 * copies of the Software, and to permit persons to whom the Software is
14 * furnished to do so, subject to the following conditions:
16 * The above copyright notice and this permission notice shall be included in
17 * all copies or substantial portions of the Software.
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
22 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
28 #include "qemu/osdep.h"
29 #include "block/block-io.h"
30 #include "block/dirty-bitmap.h"
31 #include "qapi/error.h"
32 #include "qemu/cutils.h"
36 /* NOTICE: BME here means Bitmaps Extension and used as a namespace for
37 * _internal_ constants. Please do not use this _internal_ abbreviation for
38 * other needs and/or outside of this file. */
40 /* Bitmap directory entry constraints */
41 #define BME_MAX_TABLE_SIZE 0x8000000
42 #define BME_MAX_PHYS_SIZE 0x20000000 /* restrict BdrvDirtyBitmap size in RAM */
43 #define BME_MAX_GRANULARITY_BITS 31
44 #define BME_MIN_GRANULARITY_BITS 9
45 #define BME_MAX_NAME_SIZE 1023
47 /* Size of bitmap table entries */
48 #define BME_TABLE_ENTRY_SIZE (sizeof(uint64_t))
50 QEMU_BUILD_BUG_ON(BME_MAX_NAME_SIZE
!= BDRV_BITMAP_MAX_NAME_SIZE
);
52 #if BME_MAX_TABLE_SIZE * 8ULL > INT_MAX
53 #error In the code bitmap table physical size assumed to fit into int
56 /* Bitmap directory entry flags */
57 #define BME_RESERVED_FLAGS 0xfffffffcU
58 #define BME_FLAG_IN_USE (1U << 0)
59 #define BME_FLAG_AUTO (1U << 1)
61 /* bits [1, 8] U [56, 63] are reserved */
62 #define BME_TABLE_ENTRY_RESERVED_MASK 0xff000000000001feULL
63 #define BME_TABLE_ENTRY_OFFSET_MASK 0x00fffffffffffe00ULL
64 #define BME_TABLE_ENTRY_FLAG_ALL_ONES (1ULL << 0)
66 typedef struct QEMU_PACKED Qcow2BitmapDirEntry
{
67 /* header is 8 byte aligned */
68 uint64_t bitmap_table_offset
;
70 uint32_t bitmap_table_size
;
74 uint8_t granularity_bits
;
76 uint32_t extra_data_size
;
77 /* extra data follows */
79 } Qcow2BitmapDirEntry
;
81 typedef struct Qcow2BitmapTable
{
83 uint32_t size
; /* number of 64bit entries */
84 QSIMPLEQ_ENTRY(Qcow2BitmapTable
) entry
;
87 typedef struct Qcow2Bitmap
{
88 Qcow2BitmapTable table
;
90 uint8_t granularity_bits
;
93 BdrvDirtyBitmap
*dirty_bitmap
;
95 QSIMPLEQ_ENTRY(Qcow2Bitmap
) entry
;
97 typedef QSIMPLEQ_HEAD(Qcow2BitmapList
, Qcow2Bitmap
) Qcow2BitmapList
;
99 typedef enum BitmapType
{
100 BT_DIRTY_TRACKING_BITMAP
= 1
103 static inline bool can_write(BlockDriverState
*bs
)
105 return !bdrv_is_read_only(bs
) && !(bdrv_get_flags(bs
) & BDRV_O_INACTIVE
);
108 static int update_header_sync(BlockDriverState
*bs
)
112 ret
= qcow2_update_header(bs
);
117 return bdrv_flush(bs
->file
->bs
);
120 static inline void bitmap_table_bswap_be(uint64_t *bitmap_table
, size_t size
)
124 for (i
= 0; i
< size
; ++i
) {
125 bitmap_table
[i
] = cpu_to_be64(bitmap_table
[i
]);
129 static int check_table_entry(uint64_t entry
, int cluster_size
)
133 if (entry
& BME_TABLE_ENTRY_RESERVED_MASK
) {
137 offset
= entry
& BME_TABLE_ENTRY_OFFSET_MASK
;
139 /* if offset specified, bit 0 is reserved */
140 if (entry
& BME_TABLE_ENTRY_FLAG_ALL_ONES
) {
144 if (offset
% cluster_size
!= 0) {
152 static int64_t get_bitmap_bytes_needed(int64_t len
, uint32_t granularity
)
154 int64_t num_bits
= DIV_ROUND_UP(len
, granularity
);
156 return DIV_ROUND_UP(num_bits
, 8);
159 static int check_constraints_on_bitmap(BlockDriverState
*bs
,
161 uint32_t granularity
,
164 BDRVQcow2State
*s
= bs
->opaque
;
165 int granularity_bits
= ctz32(granularity
);
166 int64_t len
= bdrv_getlength(bs
);
167 int64_t bitmap_bytes
;
169 assume_graph_lock(); /* FIXME */
171 assert(granularity
> 0);
172 assert((granularity
& (granularity
- 1)) == 0);
175 error_setg_errno(errp
, -len
, "Failed to get size of '%s'",
176 bdrv_get_device_or_node_name(bs
));
180 if (granularity_bits
> BME_MAX_GRANULARITY_BITS
) {
181 error_setg(errp
, "Granularity exceeds maximum (%llu bytes)",
182 1ULL << BME_MAX_GRANULARITY_BITS
);
185 if (granularity_bits
< BME_MIN_GRANULARITY_BITS
) {
186 error_setg(errp
, "Granularity is under minimum (%llu bytes)",
187 1ULL << BME_MIN_GRANULARITY_BITS
);
191 bitmap_bytes
= get_bitmap_bytes_needed(len
, granularity
);
192 if ((bitmap_bytes
> (uint64_t)BME_MAX_PHYS_SIZE
) ||
193 (bitmap_bytes
> (uint64_t)BME_MAX_TABLE_SIZE
* s
->cluster_size
))
195 error_setg(errp
, "Too much space will be occupied by the bitmap. "
196 "Use larger granularity");
200 if (strlen(name
) > BME_MAX_NAME_SIZE
) {
201 error_setg(errp
, "Name length exceeds maximum (%u characters)",
209 static void clear_bitmap_table(BlockDriverState
*bs
, uint64_t *bitmap_table
,
210 uint32_t bitmap_table_size
)
212 BDRVQcow2State
*s
= bs
->opaque
;
215 for (i
= 0; i
< bitmap_table_size
; ++i
) {
216 uint64_t addr
= bitmap_table
[i
] & BME_TABLE_ENTRY_OFFSET_MASK
;
221 qcow2_free_clusters(bs
, addr
, s
->cluster_size
, QCOW2_DISCARD_ALWAYS
);
226 static int bitmap_table_load(BlockDriverState
*bs
, Qcow2BitmapTable
*tb
,
227 uint64_t **bitmap_table
)
230 BDRVQcow2State
*s
= bs
->opaque
;
234 assert(tb
->size
!= 0);
235 table
= g_try_new(uint64_t, tb
->size
);
240 assert(tb
->size
<= BME_MAX_TABLE_SIZE
);
241 ret
= bdrv_pread(bs
->file
, tb
->offset
, tb
->size
* BME_TABLE_ENTRY_SIZE
,
247 for (i
= 0; i
< tb
->size
; ++i
) {
248 table
[i
] = be64_to_cpu(table
[i
]);
249 ret
= check_table_entry(table
[i
], s
->cluster_size
);
255 *bitmap_table
= table
;
264 static int free_bitmap_clusters(BlockDriverState
*bs
, Qcow2BitmapTable
*tb
)
267 uint64_t *bitmap_table
;
269 ret
= bitmap_table_load(bs
, tb
, &bitmap_table
);
274 clear_bitmap_table(bs
, bitmap_table
, tb
->size
);
275 qcow2_free_clusters(bs
, tb
->offset
, tb
->size
* BME_TABLE_ENTRY_SIZE
,
276 QCOW2_DISCARD_OTHER
);
277 g_free(bitmap_table
);
286 * @bitmap_table entries must satisfy specification constraints.
287 * @bitmap must be cleared */
288 static int coroutine_fn GRAPH_RDLOCK
289 load_bitmap_data(BlockDriverState
*bs
, const uint64_t *bitmap_table
,
290 uint32_t bitmap_table_size
, BdrvDirtyBitmap
*bitmap
)
293 BDRVQcow2State
*s
= bs
->opaque
;
294 uint64_t offset
, limit
;
295 uint64_t bm_size
= bdrv_dirty_bitmap_size(bitmap
);
297 uint64_t i
, tab_size
=
299 bdrv_dirty_bitmap_serialization_size(bitmap
, 0, bm_size
));
301 if (tab_size
!= bitmap_table_size
|| tab_size
> BME_MAX_TABLE_SIZE
) {
305 buf
= g_malloc(s
->cluster_size
);
306 limit
= bdrv_dirty_bitmap_serialization_coverage(s
->cluster_size
, bitmap
);
307 for (i
= 0, offset
= 0; i
< tab_size
; ++i
, offset
+= limit
) {
308 uint64_t count
= MIN(bm_size
- offset
, limit
);
309 uint64_t entry
= bitmap_table
[i
];
310 uint64_t data_offset
= entry
& BME_TABLE_ENTRY_OFFSET_MASK
;
312 assert(check_table_entry(entry
, s
->cluster_size
) == 0);
314 if (data_offset
== 0) {
315 if (entry
& BME_TABLE_ENTRY_FLAG_ALL_ONES
) {
316 bdrv_dirty_bitmap_deserialize_ones(bitmap
, offset
, count
,
319 /* No need to deserialize zeros because the dirty bitmap is
323 ret
= bdrv_co_pread(bs
->file
, data_offset
, s
->cluster_size
, buf
, 0);
327 bdrv_dirty_bitmap_deserialize_part(bitmap
, buf
, offset
, count
,
333 bdrv_dirty_bitmap_deserialize_finish(bitmap
);
341 static coroutine_fn GRAPH_RDLOCK
342 BdrvDirtyBitmap
*load_bitmap(BlockDriverState
*bs
,
343 Qcow2Bitmap
*bm
, Error
**errp
)
346 uint64_t *bitmap_table
= NULL
;
347 uint32_t granularity
;
348 BdrvDirtyBitmap
*bitmap
= NULL
;
350 granularity
= 1U << bm
->granularity_bits
;
351 bitmap
= bdrv_create_dirty_bitmap(bs
, granularity
, bm
->name
, errp
);
352 if (bitmap
== NULL
) {
356 if (bm
->flags
& BME_FLAG_IN_USE
) {
357 /* Data is unusable, skip loading it */
361 ret
= bitmap_table_load(bs
, &bm
->table
, &bitmap_table
);
363 error_setg_errno(errp
, -ret
,
364 "Could not read bitmap_table table from image for "
365 "bitmap '%s'", bm
->name
);
369 ret
= load_bitmap_data(bs
, bitmap_table
, bm
->table
.size
, bitmap
);
371 error_setg_errno(errp
, -ret
, "Could not read bitmap '%s' from image",
376 g_free(bitmap_table
);
380 g_free(bitmap_table
);
381 if (bitmap
!= NULL
) {
382 bdrv_release_dirty_bitmap(bitmap
);
393 * Bitmap List private functions
394 * Only Bitmap List knows about bitmap directory structure in Qcow2.
397 static inline void bitmap_dir_entry_to_cpu(Qcow2BitmapDirEntry
*entry
)
399 entry
->bitmap_table_offset
= be64_to_cpu(entry
->bitmap_table_offset
);
400 entry
->bitmap_table_size
= be32_to_cpu(entry
->bitmap_table_size
);
401 entry
->flags
= be32_to_cpu(entry
->flags
);
402 entry
->name_size
= be16_to_cpu(entry
->name_size
);
403 entry
->extra_data_size
= be32_to_cpu(entry
->extra_data_size
);
406 static inline void bitmap_dir_entry_to_be(Qcow2BitmapDirEntry
*entry
)
408 entry
->bitmap_table_offset
= cpu_to_be64(entry
->bitmap_table_offset
);
409 entry
->bitmap_table_size
= cpu_to_be32(entry
->bitmap_table_size
);
410 entry
->flags
= cpu_to_be32(entry
->flags
);
411 entry
->name_size
= cpu_to_be16(entry
->name_size
);
412 entry
->extra_data_size
= cpu_to_be32(entry
->extra_data_size
);
415 static inline int calc_dir_entry_size(size_t name_size
, size_t extra_data_size
)
417 int size
= sizeof(Qcow2BitmapDirEntry
) + name_size
+ extra_data_size
;
418 return ROUND_UP(size
, 8);
421 static inline int dir_entry_size(Qcow2BitmapDirEntry
*entry
)
423 return calc_dir_entry_size(entry
->name_size
, entry
->extra_data_size
);
426 static inline const char *dir_entry_name_field(Qcow2BitmapDirEntry
*entry
)
428 return (const char *)(entry
+ 1) + entry
->extra_data_size
;
431 static inline char *dir_entry_copy_name(Qcow2BitmapDirEntry
*entry
)
433 const char *name_field
= dir_entry_name_field(entry
);
434 return g_strndup(name_field
, entry
->name_size
);
437 static inline Qcow2BitmapDirEntry
*next_dir_entry(Qcow2BitmapDirEntry
*entry
)
439 return (Qcow2BitmapDirEntry
*)((uint8_t *)entry
+ dir_entry_size(entry
));
442 static int check_dir_entry(BlockDriverState
*bs
, Qcow2BitmapDirEntry
*entry
)
444 BDRVQcow2State
*s
= bs
->opaque
;
445 uint64_t phys_bitmap_bytes
;
448 bool fail
= (entry
->bitmap_table_size
== 0) ||
449 (entry
->bitmap_table_offset
== 0) ||
450 (entry
->bitmap_table_offset
% s
->cluster_size
) ||
451 (entry
->bitmap_table_size
> BME_MAX_TABLE_SIZE
) ||
452 (entry
->granularity_bits
> BME_MAX_GRANULARITY_BITS
) ||
453 (entry
->granularity_bits
< BME_MIN_GRANULARITY_BITS
) ||
454 (entry
->flags
& BME_RESERVED_FLAGS
) ||
455 (entry
->name_size
> BME_MAX_NAME_SIZE
) ||
456 (entry
->type
!= BT_DIRTY_TRACKING_BITMAP
);
462 phys_bitmap_bytes
= (uint64_t)entry
->bitmap_table_size
* s
->cluster_size
;
463 len
= bdrv_getlength(bs
);
469 if (phys_bitmap_bytes
> BME_MAX_PHYS_SIZE
) {
473 if (!(entry
->flags
& BME_FLAG_IN_USE
) &&
474 (len
> ((phys_bitmap_bytes
* 8) << entry
->granularity_bits
)))
477 * We've loaded a valid bitmap (IN_USE not set) or we are going to
478 * store a valid bitmap, but the allocated bitmap table size is not
479 * enough to store this bitmap.
481 * Note, that it's OK to have an invalid bitmap with invalid size due
482 * to a bitmap that was not correctly saved after image resize.
490 static inline void bitmap_directory_to_be(uint8_t *dir
, size_t size
)
492 uint8_t *end
= dir
+ size
;
494 Qcow2BitmapDirEntry
*e
= (Qcow2BitmapDirEntry
*)dir
;
495 dir
+= dir_entry_size(e
);
497 bitmap_dir_entry_to_be(e
);
502 * Bitmap List public functions
505 static void bitmap_free(Qcow2Bitmap
*bm
)
515 static void bitmap_list_free(Qcow2BitmapList
*bm_list
)
519 if (bm_list
== NULL
) {
523 while ((bm
= QSIMPLEQ_FIRST(bm_list
)) != NULL
) {
524 QSIMPLEQ_REMOVE_HEAD(bm_list
, entry
);
531 static Qcow2BitmapList
*bitmap_list_new(void)
533 Qcow2BitmapList
*bm_list
= g_new(Qcow2BitmapList
, 1);
534 QSIMPLEQ_INIT(bm_list
);
539 static uint32_t bitmap_list_count(Qcow2BitmapList
*bm_list
)
542 uint32_t nb_bitmaps
= 0;
544 QSIMPLEQ_FOREACH(bm
, bm_list
, entry
) {
552 * Get bitmap list from qcow2 image. Actually reads bitmap directory,
553 * checks it and convert to bitmap list.
555 static Qcow2BitmapList
*bitmap_list_load(BlockDriverState
*bs
, uint64_t offset
,
556 uint64_t size
, Error
**errp
)
559 BDRVQcow2State
*s
= bs
->opaque
;
560 uint8_t *dir
, *dir_end
;
561 Qcow2BitmapDirEntry
*e
;
562 uint32_t nb_dir_entries
= 0;
563 Qcow2BitmapList
*bm_list
= NULL
;
566 error_setg(errp
, "Requested bitmap directory size is zero");
570 if (size
> QCOW2_MAX_BITMAP_DIRECTORY_SIZE
) {
571 error_setg(errp
, "Requested bitmap directory size is too big");
575 dir
= g_try_malloc(size
);
577 error_setg(errp
, "Failed to allocate space for bitmap directory");
580 dir_end
= dir
+ size
;
582 ret
= bdrv_pread(bs
->file
, offset
, size
, dir
, 0);
584 error_setg_errno(errp
, -ret
, "Failed to read bitmap directory");
588 bm_list
= bitmap_list_new();
589 for (e
= (Qcow2BitmapDirEntry
*)dir
;
590 e
< (Qcow2BitmapDirEntry
*)dir_end
;
591 e
= next_dir_entry(e
))
595 if ((uint8_t *)(e
+ 1) > dir_end
) {
599 if (++nb_dir_entries
> s
->nb_bitmaps
) {
600 error_setg(errp
, "More bitmaps found than specified in header"
604 bitmap_dir_entry_to_cpu(e
);
606 if ((uint8_t *)next_dir_entry(e
) > dir_end
) {
610 if (e
->extra_data_size
!= 0) {
611 error_setg(errp
, "Bitmap extra data is not supported");
615 ret
= check_dir_entry(bs
, e
);
617 error_setg(errp
, "Bitmap '%.*s' doesn't satisfy the constraints",
618 e
->name_size
, dir_entry_name_field(e
));
622 bm
= g_new0(Qcow2Bitmap
, 1);
623 bm
->table
.offset
= e
->bitmap_table_offset
;
624 bm
->table
.size
= e
->bitmap_table_size
;
625 bm
->flags
= e
->flags
;
626 bm
->granularity_bits
= e
->granularity_bits
;
627 bm
->name
= dir_entry_copy_name(e
);
628 QSIMPLEQ_INSERT_TAIL(bm_list
, bm
, entry
);
631 if (nb_dir_entries
!= s
->nb_bitmaps
) {
632 error_setg(errp
, "Less bitmaps found than specified in header"
637 if ((uint8_t *)e
!= dir_end
) {
645 error_setg(errp
, "Broken bitmap directory");
649 bitmap_list_free(bm_list
);
655 qcow2_check_bitmaps_refcounts(BlockDriverState
*bs
, BdrvCheckResult
*res
,
656 void **refcount_table
,
657 int64_t *refcount_table_size
)
660 BDRVQcow2State
*s
= bs
->opaque
;
661 Qcow2BitmapList
*bm_list
;
664 if (s
->nb_bitmaps
== 0) {
668 ret
= qcow2_inc_refcounts_imrt(bs
, res
, refcount_table
, refcount_table_size
,
669 s
->bitmap_directory_offset
,
670 s
->bitmap_directory_size
);
675 bm_list
= bitmap_list_load(bs
, s
->bitmap_directory_offset
,
676 s
->bitmap_directory_size
, NULL
);
677 if (bm_list
== NULL
) {
682 QSIMPLEQ_FOREACH(bm
, bm_list
, entry
) {
683 uint64_t *bitmap_table
= NULL
;
686 ret
= qcow2_inc_refcounts_imrt(bs
, res
,
687 refcount_table
, refcount_table_size
,
689 bm
->table
.size
* BME_TABLE_ENTRY_SIZE
);
694 ret
= bitmap_table_load(bs
, &bm
->table
, &bitmap_table
);
700 for (i
= 0; i
< bm
->table
.size
; ++i
) {
701 uint64_t entry
= bitmap_table
[i
];
702 uint64_t offset
= entry
& BME_TABLE_ENTRY_OFFSET_MASK
;
704 if (check_table_entry(entry
, s
->cluster_size
) < 0) {
713 ret
= qcow2_inc_refcounts_imrt(bs
, res
,
714 refcount_table
, refcount_table_size
,
715 offset
, s
->cluster_size
);
717 g_free(bitmap_table
);
722 g_free(bitmap_table
);
726 bitmap_list_free(bm_list
);
732 * Store bitmap list to qcow2 image as a bitmap directory.
733 * Everything is checked.
735 static int bitmap_list_store(BlockDriverState
*bs
, Qcow2BitmapList
*bm_list
,
736 uint64_t *offset
, uint64_t *size
, bool in_place
)
740 int64_t dir_offset
= 0;
741 uint64_t dir_size
= 0;
743 Qcow2BitmapDirEntry
*e
;
745 QSIMPLEQ_FOREACH(bm
, bm_list
, entry
) {
746 dir_size
+= calc_dir_entry_size(strlen(bm
->name
), 0);
749 if (dir_size
== 0 || dir_size
> QCOW2_MAX_BITMAP_DIRECTORY_SIZE
) {
754 if (*size
!= dir_size
|| *offset
== 0) {
758 dir_offset
= *offset
;
761 dir
= g_try_malloc0(dir_size
);
766 e
= (Qcow2BitmapDirEntry
*)dir
;
767 QSIMPLEQ_FOREACH(bm
, bm_list
, entry
) {
768 e
->bitmap_table_offset
= bm
->table
.offset
;
769 e
->bitmap_table_size
= bm
->table
.size
;
770 e
->flags
= bm
->flags
;
771 e
->type
= BT_DIRTY_TRACKING_BITMAP
;
772 e
->granularity_bits
= bm
->granularity_bits
;
773 e
->name_size
= strlen(bm
->name
);
774 e
->extra_data_size
= 0;
775 memcpy(e
+ 1, bm
->name
, e
->name_size
);
777 if (check_dir_entry(bs
, e
) < 0) {
782 e
= next_dir_entry(e
);
785 bitmap_directory_to_be(dir
, dir_size
);
788 dir_offset
= qcow2_alloc_clusters(bs
, dir_size
);
789 if (dir_offset
< 0) {
795 /* Actually, even in the in-place case ignoring QCOW2_OL_BITMAP_DIRECTORY
796 * is not necessary, because we drop QCOW2_AUTOCLEAR_BITMAPS when updating
797 * bitmap directory in-place (actually, turn-off the extension), which is
798 * checked in qcow2_check_metadata_overlap() */
799 ret
= qcow2_pre_write_overlap_check(
800 bs
, in_place
? QCOW2_OL_BITMAP_DIRECTORY
: 0, dir_offset
, dir_size
,
806 ret
= bdrv_pwrite(bs
->file
, dir_offset
, dir_size
, dir
, 0);
815 *offset
= dir_offset
;
823 if (!in_place
&& dir_offset
> 0) {
824 qcow2_free_clusters(bs
, dir_offset
, dir_size
, QCOW2_DISCARD_OTHER
);
834 static int update_ext_header_and_dir_in_place(BlockDriverState
*bs
,
835 Qcow2BitmapList
*bm_list
)
837 BDRVQcow2State
*s
= bs
->opaque
;
840 if (!(s
->autoclear_features
& QCOW2_AUTOCLEAR_BITMAPS
) ||
841 bm_list
== NULL
|| QSIMPLEQ_EMPTY(bm_list
) ||
842 bitmap_list_count(bm_list
) != s
->nb_bitmaps
)
847 s
->autoclear_features
&= ~(uint64_t)QCOW2_AUTOCLEAR_BITMAPS
;
848 ret
= update_header_sync(bs
);
850 /* Two variants are possible here:
851 * 1. Autoclear flag is dropped, all bitmaps will be lost.
852 * 2. Autoclear flag is not dropped, old state is left.
857 /* autoclear bit is not set, so we can safely update bitmap directory */
859 ret
= bitmap_list_store(bs
, bm_list
, &s
->bitmap_directory_offset
,
860 &s
->bitmap_directory_size
, true);
862 /* autoclear bit is cleared, so all leaked clusters would be removed on
867 ret
= update_header_sync(bs
);
869 /* autoclear bit is cleared, so all leaked clusters would be removed on
874 s
->autoclear_features
|= QCOW2_AUTOCLEAR_BITMAPS
;
875 return update_header_sync(bs
);
876 /* If final update_header_sync() fails, two variants are possible:
877 * 1. Autoclear flag is not set, all bitmaps will be lost.
878 * 2. Autoclear flag is set, header and directory are successfully updated.
882 static int update_ext_header_and_dir(BlockDriverState
*bs
,
883 Qcow2BitmapList
*bm_list
)
885 BDRVQcow2State
*s
= bs
->opaque
;
887 uint64_t new_offset
= 0;
888 uint64_t new_size
= 0;
889 uint32_t new_nb_bitmaps
= 0;
890 uint64_t old_offset
= s
->bitmap_directory_offset
;
891 uint64_t old_size
= s
->bitmap_directory_size
;
892 uint32_t old_nb_bitmaps
= s
->nb_bitmaps
;
893 uint64_t old_autocl
= s
->autoclear_features
;
895 if (bm_list
!= NULL
&& !QSIMPLEQ_EMPTY(bm_list
)) {
896 new_nb_bitmaps
= bitmap_list_count(bm_list
);
898 if (new_nb_bitmaps
> QCOW2_MAX_BITMAPS
) {
902 ret
= bitmap_list_store(bs
, bm_list
, &new_offset
, &new_size
, false);
907 ret
= qcow2_flush_caches(bs
);
912 s
->autoclear_features
|= QCOW2_AUTOCLEAR_BITMAPS
;
914 s
->autoclear_features
&= ~(uint64_t)QCOW2_AUTOCLEAR_BITMAPS
;
917 s
->bitmap_directory_offset
= new_offset
;
918 s
->bitmap_directory_size
= new_size
;
919 s
->nb_bitmaps
= new_nb_bitmaps
;
921 ret
= update_header_sync(bs
);
927 qcow2_free_clusters(bs
, old_offset
, old_size
, QCOW2_DISCARD_OTHER
);
933 if (new_offset
> 0) {
934 qcow2_free_clusters(bs
, new_offset
, new_size
, QCOW2_DISCARD_OTHER
);
937 s
->bitmap_directory_offset
= old_offset
;
938 s
->bitmap_directory_size
= old_size
;
939 s
->nb_bitmaps
= old_nb_bitmaps
;
940 s
->autoclear_features
= old_autocl
;
945 /* for g_slist_foreach for GSList of BdrvDirtyBitmap* elements */
946 static void release_dirty_bitmap_helper(gpointer bitmap
,
949 bdrv_release_dirty_bitmap(bitmap
);
952 /* for g_slist_foreach for GSList of BdrvDirtyBitmap* elements */
953 static void set_readonly_helper(gpointer bitmap
, gpointer value
)
955 bdrv_dirty_bitmap_set_readonly(bitmap
, (bool)value
);
959 * Return true on success, false on failure.
960 * If header_updated is not NULL then it is set appropriately regardless of
963 bool coroutine_fn GRAPH_RDLOCK
964 qcow2_load_dirty_bitmaps(BlockDriverState
*bs
,
965 bool *header_updated
, Error
**errp
)
967 BDRVQcow2State
*s
= bs
->opaque
;
968 Qcow2BitmapList
*bm_list
;
970 GSList
*created_dirty_bitmaps
= NULL
;
971 bool needs_update
= false;
973 if (header_updated
) {
974 *header_updated
= false;
977 if (s
->nb_bitmaps
== 0) {
978 /* No bitmaps - nothing to do */
982 bm_list
= bitmap_list_load(bs
, s
->bitmap_directory_offset
,
983 s
->bitmap_directory_size
, errp
);
984 if (bm_list
== NULL
) {
988 QSIMPLEQ_FOREACH(bm
, bm_list
, entry
) {
989 BdrvDirtyBitmap
*bitmap
;
991 if ((bm
->flags
& BME_FLAG_IN_USE
) &&
992 bdrv_find_dirty_bitmap(bs
, bm
->name
))
995 * We already have corresponding BdrvDirtyBitmap, and bitmap in the
996 * image is marked IN_USE. Firstly, this state is valid, no reason
997 * to consider existing BdrvDirtyBitmap to be bad. Secondly it's
998 * absolutely possible, when we do migration with shared storage
999 * with dirty-bitmaps capability enabled: if the bitmap was loaded
1000 * from this storage before migration start, the storage will
1001 * of-course contain IN_USE outdated version of the bitmap, and we
1002 * should not load it on migration target, as we already have this
1003 * bitmap, being migrated.
1008 bitmap
= load_bitmap(bs
, bm
, errp
);
1009 if (bitmap
== NULL
) {
1013 bdrv_dirty_bitmap_set_persistence(bitmap
, true);
1014 if (bm
->flags
& BME_FLAG_IN_USE
) {
1015 bdrv_dirty_bitmap_set_inconsistent(bitmap
);
1017 /* NB: updated flags only get written if can_write(bs) is true. */
1018 bm
->flags
|= BME_FLAG_IN_USE
;
1019 needs_update
= true;
1021 if (!(bm
->flags
& BME_FLAG_AUTO
)) {
1022 bdrv_disable_dirty_bitmap(bitmap
);
1024 created_dirty_bitmaps
=
1025 g_slist_append(created_dirty_bitmaps
, bitmap
);
1028 if (needs_update
&& can_write(bs
)) {
1029 /* in_use flags must be updated */
1030 int ret
= update_ext_header_and_dir_in_place(bs
, bm_list
);
1032 error_setg_errno(errp
, -ret
, "Can't update bitmap directory");
1035 if (header_updated
) {
1036 *header_updated
= true;
1040 if (!can_write(bs
)) {
1041 g_slist_foreach(created_dirty_bitmaps
, set_readonly_helper
,
1045 g_slist_free(created_dirty_bitmaps
);
1046 bitmap_list_free(bm_list
);
1051 g_slist_foreach(created_dirty_bitmaps
, release_dirty_bitmap_helper
, bs
);
1052 g_slist_free(created_dirty_bitmaps
);
1053 bitmap_list_free(bm_list
);
1059 static Qcow2BitmapInfoFlagsList
*get_bitmap_info_flags(uint32_t flags
)
1061 Qcow2BitmapInfoFlagsList
*list
= NULL
;
1062 Qcow2BitmapInfoFlagsList
**tail
= &list
;
1065 static const struct {
1066 int bme
; /* Bitmap directory entry flags */
1067 int info
; /* The flags to report to the user */
1069 { BME_FLAG_IN_USE
, QCOW2_BITMAP_INFO_FLAGS_IN_USE
},
1070 { BME_FLAG_AUTO
, QCOW2_BITMAP_INFO_FLAGS_AUTO
},
1073 int map_size
= ARRAY_SIZE(map
);
1075 for (i
= 0; i
< map_size
; ++i
) {
1076 if (flags
& map
[i
].bme
) {
1077 QAPI_LIST_APPEND(tail
, map
[i
].info
);
1078 flags
&= ~map
[i
].bme
;
1081 /* Check if the BME_* mapping above is complete */
1088 * qcow2_get_bitmap_info_list()
1089 * Returns a list of QCOW2 bitmap details.
1090 * On success return true with info_list set (note, that if there are no
1091 * bitmaps, info_list is set to NULL).
1092 * On failure return false with errp set.
1094 bool qcow2_get_bitmap_info_list(BlockDriverState
*bs
,
1095 Qcow2BitmapInfoList
**info_list
, Error
**errp
)
1097 BDRVQcow2State
*s
= bs
->opaque
;
1098 Qcow2BitmapList
*bm_list
;
1100 Qcow2BitmapInfoList
**tail
;
1102 if (s
->nb_bitmaps
== 0) {
1107 bm_list
= bitmap_list_load(bs
, s
->bitmap_directory_offset
,
1108 s
->bitmap_directory_size
, errp
);
1116 QSIMPLEQ_FOREACH(bm
, bm_list
, entry
) {
1117 Qcow2BitmapInfo
*info
= g_new0(Qcow2BitmapInfo
, 1);
1118 info
->granularity
= 1U << bm
->granularity_bits
;
1119 info
->name
= g_strdup(bm
->name
);
1120 info
->flags
= get_bitmap_info_flags(bm
->flags
& ~BME_RESERVED_FLAGS
);
1121 QAPI_LIST_APPEND(tail
, info
);
1124 bitmap_list_free(bm_list
);
1129 int qcow2_reopen_bitmaps_rw(BlockDriverState
*bs
, Error
**errp
)
1131 BDRVQcow2State
*s
= bs
->opaque
;
1132 Qcow2BitmapList
*bm_list
;
1134 GSList
*ro_dirty_bitmaps
= NULL
;
1136 bool need_header_update
= false;
1138 if (s
->nb_bitmaps
== 0) {
1139 /* No bitmaps - nothing to do */
1143 bm_list
= bitmap_list_load(bs
, s
->bitmap_directory_offset
,
1144 s
->bitmap_directory_size
, errp
);
1145 if (bm_list
== NULL
) {
1149 QSIMPLEQ_FOREACH(bm
, bm_list
, entry
) {
1150 BdrvDirtyBitmap
*bitmap
= bdrv_find_dirty_bitmap(bs
, bm
->name
);
1153 error_setg(errp
, "Unexpected bitmap '%s' in image '%s'",
1154 bm
->name
, bs
->filename
);
1158 if (!(bm
->flags
& BME_FLAG_IN_USE
)) {
1159 if (!bdrv_dirty_bitmap_readonly(bitmap
)) {
1160 error_setg(errp
, "Corruption: bitmap '%s' is not marked IN_USE "
1161 "in the image '%s' and not marked readonly in RAM",
1162 bm
->name
, bs
->filename
);
1165 if (bdrv_dirty_bitmap_inconsistent(bitmap
)) {
1166 error_setg(errp
, "Corruption: bitmap '%s' is inconsistent but "
1167 "is not marked IN_USE in the image '%s'", bm
->name
,
1172 bm
->flags
|= BME_FLAG_IN_USE
;
1173 need_header_update
= true;
1176 * What if flags already has BME_FLAG_IN_USE ?
1178 * 1. if we are reopening RW -> RW it's OK, of course.
1179 * 2. if we are reopening RO -> RW:
1180 * 2.1 if @bitmap is inconsistent, it's OK. It means that it was
1181 * inconsistent (IN_USE) when we loaded it
1182 * 2.2 if @bitmap is not inconsistent. This seems to be impossible
1183 * and implies third party interaction. Let's error-out for
1186 if (bdrv_dirty_bitmap_readonly(bitmap
) &&
1187 !bdrv_dirty_bitmap_inconsistent(bitmap
))
1189 error_setg(errp
, "Corruption: bitmap '%s' is marked IN_USE "
1190 "in the image '%s' but it is readonly and "
1191 "consistent in RAM",
1192 bm
->name
, bs
->filename
);
1197 if (bdrv_dirty_bitmap_readonly(bitmap
)) {
1198 ro_dirty_bitmaps
= g_slist_append(ro_dirty_bitmaps
, bitmap
);
1202 if (need_header_update
) {
1203 if (!can_write(bs
->file
->bs
) || !(bs
->file
->perm
& BLK_PERM_WRITE
)) {
1204 error_setg(errp
, "Failed to reopen bitmaps rw: no write access "
1205 "the protocol file");
1209 /* in_use flags must be updated */
1210 ret
= update_ext_header_and_dir_in_place(bs
, bm_list
);
1212 error_setg_errno(errp
, -ret
, "Cannot update bitmap directory");
1217 g_slist_foreach(ro_dirty_bitmaps
, set_readonly_helper
, (gpointer
)false);
1221 g_slist_free(ro_dirty_bitmaps
);
1222 bitmap_list_free(bm_list
);
1227 /* Checks to see if it's safe to resize bitmaps */
1228 int coroutine_fn
qcow2_truncate_bitmaps_check(BlockDriverState
*bs
, Error
**errp
)
1230 BDRVQcow2State
*s
= bs
->opaque
;
1231 Qcow2BitmapList
*bm_list
;
1235 if (s
->nb_bitmaps
== 0) {
1239 bm_list
= bitmap_list_load(bs
, s
->bitmap_directory_offset
,
1240 s
->bitmap_directory_size
, errp
);
1241 if (bm_list
== NULL
) {
1245 QSIMPLEQ_FOREACH(bm
, bm_list
, entry
) {
1246 BdrvDirtyBitmap
*bitmap
= bdrv_find_dirty_bitmap(bs
, bm
->name
);
1247 if (bitmap
== NULL
) {
1249 * We rely on all bitmaps being in-memory to be able to resize them,
1250 * Otherwise, we'd need to resize them on disk explicitly
1252 error_setg(errp
, "Cannot resize qcow2 with persistent bitmaps that "
1253 "were not loaded into memory");
1259 * The checks against readonly and busy are redundant, but certainly
1260 * do no harm. checks against inconsistent are crucial:
1262 if (bdrv_dirty_bitmap_check(bitmap
, BDRV_BITMAP_DEFAULT
, errp
)) {
1269 bitmap_list_free(bm_list
);
1273 /* store_bitmap_data()
1274 * Store bitmap to image, filling bitmap table accordingly.
1276 static uint64_t *store_bitmap_data(BlockDriverState
*bs
,
1277 BdrvDirtyBitmap
*bitmap
,
1278 uint32_t *bitmap_table_size
, Error
**errp
)
1281 BDRVQcow2State
*s
= bs
->opaque
;
1284 uint64_t bm_size
= bdrv_dirty_bitmap_size(bitmap
);
1285 const char *bm_name
= bdrv_dirty_bitmap_name(bitmap
);
1286 uint8_t *buf
= NULL
;
1290 bdrv_dirty_bitmap_serialization_size(bitmap
, 0, bm_size
));
1292 if (tb_size
> BME_MAX_TABLE_SIZE
||
1293 tb_size
* s
->cluster_size
> BME_MAX_PHYS_SIZE
)
1295 error_setg(errp
, "Bitmap '%s' is too big", bm_name
);
1299 tb
= g_try_new0(uint64_t, tb_size
);
1301 error_setg(errp
, "No memory");
1305 buf
= g_malloc(s
->cluster_size
);
1306 limit
= bdrv_dirty_bitmap_serialization_coverage(s
->cluster_size
, bitmap
);
1307 assert(DIV_ROUND_UP(bm_size
, limit
) == tb_size
);
1310 while ((offset
= bdrv_dirty_bitmap_next_dirty(bitmap
, offset
, INT64_MAX
))
1313 uint64_t cluster
= offset
/ limit
;
1314 uint64_t end
, write_size
;
1318 * We found the first dirty offset, but want to write out the
1319 * entire cluster of the bitmap that includes that offset,
1320 * including any leading zero bits.
1322 offset
= QEMU_ALIGN_DOWN(offset
, limit
);
1323 end
= MIN(bm_size
, offset
+ limit
);
1324 write_size
= bdrv_dirty_bitmap_serialization_size(bitmap
, offset
,
1326 assert(write_size
<= s
->cluster_size
);
1328 off
= qcow2_alloc_clusters(bs
, s
->cluster_size
);
1330 error_setg_errno(errp
, -off
,
1331 "Failed to allocate clusters for bitmap '%s'",
1337 bdrv_dirty_bitmap_serialize_part(bitmap
, buf
, offset
, end
- offset
);
1338 if (write_size
< s
->cluster_size
) {
1339 memset(buf
+ write_size
, 0, s
->cluster_size
- write_size
);
1342 ret
= qcow2_pre_write_overlap_check(bs
, 0, off
, s
->cluster_size
, false);
1344 error_setg_errno(errp
, -ret
, "Qcow2 overlap check failed");
1348 ret
= bdrv_pwrite(bs
->file
, off
, s
->cluster_size
, buf
, 0);
1350 error_setg_errno(errp
, -ret
, "Failed to write bitmap '%s' to file",
1358 *bitmap_table_size
= tb_size
;
1364 clear_bitmap_table(bs
, tb
, tb_size
);
1372 * Store bm->dirty_bitmap to qcow2.
1373 * Set bm->table_offset and bm->table_size accordingly.
1375 static int store_bitmap(BlockDriverState
*bs
, Qcow2Bitmap
*bm
, Error
**errp
)
1381 BdrvDirtyBitmap
*bitmap
= bm
->dirty_bitmap
;
1382 const char *bm_name
;
1384 assert(bitmap
!= NULL
);
1386 bm_name
= bdrv_dirty_bitmap_name(bitmap
);
1388 tb
= store_bitmap_data(bs
, bitmap
, &tb_size
, errp
);
1393 assert(tb_size
<= BME_MAX_TABLE_SIZE
);
1394 tb_offset
= qcow2_alloc_clusters(bs
, tb_size
* sizeof(tb
[0]));
1395 if (tb_offset
< 0) {
1396 error_setg_errno(errp
, -tb_offset
,
1397 "Failed to allocate clusters for bitmap '%s'",
1403 ret
= qcow2_pre_write_overlap_check(bs
, 0, tb_offset
,
1404 tb_size
* sizeof(tb
[0]), false);
1406 error_setg_errno(errp
, -ret
, "Qcow2 overlap check failed");
1410 bitmap_table_bswap_be(tb
, tb_size
);
1411 ret
= bdrv_pwrite(bs
->file
, tb_offset
, tb_size
* sizeof(tb
[0]), tb
, 0);
1413 bitmap_table_bswap_be(tb
, tb_size
);
1414 error_setg_errno(errp
, -ret
, "Failed to write bitmap '%s' to file",
1421 bm
->table
.offset
= tb_offset
;
1422 bm
->table
.size
= tb_size
;
1427 clear_bitmap_table(bs
, tb
, tb_size
);
1429 if (tb_offset
> 0) {
1430 qcow2_free_clusters(bs
, tb_offset
, tb_size
* sizeof(tb
[0]),
1431 QCOW2_DISCARD_OTHER
);
1439 static Qcow2Bitmap
*find_bitmap_by_name(Qcow2BitmapList
*bm_list
,
1444 QSIMPLEQ_FOREACH(bm
, bm_list
, entry
) {
1445 if (strcmp(name
, bm
->name
) == 0) {
1453 int coroutine_fn
qcow2_co_remove_persistent_dirty_bitmap(BlockDriverState
*bs
,
1458 BDRVQcow2State
*s
= bs
->opaque
;
1459 Qcow2Bitmap
*bm
= NULL
;
1460 Qcow2BitmapList
*bm_list
;
1462 if (s
->nb_bitmaps
== 0) {
1464 * Absence of the bitmap is not an error: see explanation above
1465 * bdrv_co_remove_persistent_dirty_bitmap() definition.
1470 qemu_co_mutex_lock(&s
->lock
);
1472 bm_list
= bitmap_list_load(bs
, s
->bitmap_directory_offset
,
1473 s
->bitmap_directory_size
, errp
);
1474 if (bm_list
== NULL
) {
1479 bm
= find_bitmap_by_name(bm_list
, name
);
1481 /* Absence of the bitmap is not an error, see above. */
1486 QSIMPLEQ_REMOVE(bm_list
, bm
, Qcow2Bitmap
, entry
);
1488 ret
= update_ext_header_and_dir(bs
, bm_list
);
1490 error_setg_errno(errp
, -ret
, "Failed to update bitmap extension");
1494 free_bitmap_clusters(bs
, &bm
->table
);
1497 qemu_co_mutex_unlock(&s
->lock
);
1500 bitmap_list_free(bm_list
);
1506 * qcow2_store_persistent_dirty_bitmaps
1508 * Stores persistent BdrvDirtyBitmap objects.
1510 * @release_stored: if true, release BdrvDirtyBitmap's after storing to the
1511 * image. This is used in two cases, both via qcow2_inactivate:
1512 * 1. bdrv_close: It's correct to remove bitmaps on close.
1513 * 2. migration: If bitmaps are migrated through migration channel via
1514 * 'dirty-bitmaps' migration capability they are not handled by this code.
1515 * Otherwise, it's OK to drop BdrvDirtyBitmap's and reload them on
1518 * Anyway, it's correct to remove BdrvDirtyBitmap's on inactivation, as
1519 * inactivation means that we lose control on disk, and therefore on bitmaps,
1520 * we should sync them and do not touch more.
1522 * Contrariwise, we don't want to release any bitmaps on just reopen-to-ro,
1523 * when we need to store them, as image is still under our control, and it's
1524 * good to keep all the bitmaps in read-only mode. Moreover, keeping them
1525 * read-only is correct because this is what would happen if we opened the node
1526 * readonly to begin with, and whether we opened directly or reopened to that
1527 * state shouldn't matter for the state we get afterward.
1529 bool qcow2_store_persistent_dirty_bitmaps(BlockDriverState
*bs
,
1530 bool release_stored
, Error
**errp
)
1533 BdrvDirtyBitmap
*bitmap
;
1534 BDRVQcow2State
*s
= bs
->opaque
;
1535 uint32_t new_nb_bitmaps
= s
->nb_bitmaps
;
1536 uint64_t new_dir_size
= s
->bitmap_directory_size
;
1538 Qcow2BitmapList
*bm_list
;
1540 QSIMPLEQ_HEAD(, Qcow2BitmapTable
) drop_tables
;
1541 Qcow2BitmapTable
*tb
, *tb_next
;
1542 bool need_write
= false;
1544 QSIMPLEQ_INIT(&drop_tables
);
1546 if (s
->nb_bitmaps
== 0) {
1547 bm_list
= bitmap_list_new();
1549 bm_list
= bitmap_list_load(bs
, s
->bitmap_directory_offset
,
1550 s
->bitmap_directory_size
, errp
);
1551 if (bm_list
== NULL
) {
1556 /* check constraints and names */
1557 FOR_EACH_DIRTY_BITMAP(bs
, bitmap
) {
1558 const char *name
= bdrv_dirty_bitmap_name(bitmap
);
1559 uint32_t granularity
= bdrv_dirty_bitmap_granularity(bitmap
);
1561 if (!bdrv_dirty_bitmap_get_persistence(bitmap
) ||
1562 bdrv_dirty_bitmap_inconsistent(bitmap
)) {
1566 if (bdrv_dirty_bitmap_readonly(bitmap
)) {
1568 * Store the bitmap in the associated Qcow2Bitmap so it
1569 * can be released later
1571 bm
= find_bitmap_by_name(bm_list
, name
);
1573 bm
->dirty_bitmap
= bitmap
;
1580 if (check_constraints_on_bitmap(bs
, name
, granularity
, errp
) < 0) {
1581 error_prepend(errp
, "Bitmap '%s' doesn't satisfy the constraints: ",
1586 bm
= find_bitmap_by_name(bm_list
, name
);
1588 if (++new_nb_bitmaps
> QCOW2_MAX_BITMAPS
) {
1589 error_setg(errp
, "Too many persistent bitmaps");
1593 new_dir_size
+= calc_dir_entry_size(strlen(name
), 0);
1594 if (new_dir_size
> QCOW2_MAX_BITMAP_DIRECTORY_SIZE
) {
1595 error_setg(errp
, "Bitmap directory is too large");
1599 bm
= g_new0(Qcow2Bitmap
, 1);
1600 bm
->name
= g_strdup(name
);
1601 QSIMPLEQ_INSERT_TAIL(bm_list
, bm
, entry
);
1603 if (!(bm
->flags
& BME_FLAG_IN_USE
)) {
1604 error_setg(errp
, "Bitmap '%s' already exists in the image",
1608 tb
= g_memdup(&bm
->table
, sizeof(bm
->table
));
1609 bm
->table
.offset
= 0;
1611 QSIMPLEQ_INSERT_TAIL(&drop_tables
, tb
, entry
);
1613 bm
->flags
= bdrv_dirty_bitmap_enabled(bitmap
) ? BME_FLAG_AUTO
: 0;
1614 bm
->granularity_bits
= ctz32(bdrv_dirty_bitmap_granularity(bitmap
));
1615 bm
->dirty_bitmap
= bitmap
;
1622 if (!can_write(bs
)) {
1623 error_setg(errp
, "No write access");
1627 /* allocate clusters and store bitmaps */
1628 QSIMPLEQ_FOREACH(bm
, bm_list
, entry
) {
1629 bitmap
= bm
->dirty_bitmap
;
1631 if (bitmap
== NULL
|| bdrv_dirty_bitmap_readonly(bitmap
)) {
1635 ret
= store_bitmap(bs
, bm
, errp
);
1641 ret
= update_ext_header_and_dir(bs
, bm_list
);
1643 error_setg_errno(errp
, -ret
, "Failed to update bitmap extension");
1647 /* Bitmap directory was successfully updated, so, old data can be dropped.
1648 * TODO it is better to reuse these clusters */
1649 QSIMPLEQ_FOREACH_SAFE(tb
, &drop_tables
, entry
, tb_next
) {
1650 free_bitmap_clusters(bs
, tb
);
1655 if (release_stored
) {
1656 QSIMPLEQ_FOREACH(bm
, bm_list
, entry
) {
1657 if (bm
->dirty_bitmap
== NULL
) {
1661 bdrv_release_dirty_bitmap(bm
->dirty_bitmap
);
1665 bitmap_list_free(bm_list
);
1669 QSIMPLEQ_FOREACH(bm
, bm_list
, entry
) {
1670 if (bm
->dirty_bitmap
== NULL
|| bm
->table
.offset
== 0 ||
1671 bdrv_dirty_bitmap_readonly(bm
->dirty_bitmap
))
1676 free_bitmap_clusters(bs
, &bm
->table
);
1679 QSIMPLEQ_FOREACH_SAFE(tb
, &drop_tables
, entry
, tb_next
) {
1683 bitmap_list_free(bm_list
);
1687 int qcow2_reopen_bitmaps_ro(BlockDriverState
*bs
, Error
**errp
)
1689 BdrvDirtyBitmap
*bitmap
;
1691 if (!qcow2_store_persistent_dirty_bitmaps(bs
, false, errp
)) {
1695 FOR_EACH_DIRTY_BITMAP(bs
, bitmap
) {
1696 if (bdrv_dirty_bitmap_get_persistence(bitmap
)) {
1697 bdrv_dirty_bitmap_set_readonly(bitmap
, true);
1704 bool coroutine_fn
qcow2_co_can_store_new_dirty_bitmap(BlockDriverState
*bs
,
1706 uint32_t granularity
,
1709 BDRVQcow2State
*s
= bs
->opaque
;
1710 BdrvDirtyBitmap
*bitmap
;
1711 uint64_t bitmap_directory_size
= 0;
1712 uint32_t nb_bitmaps
= 0;
1714 if (bdrv_find_dirty_bitmap(bs
, name
)) {
1715 error_setg(errp
, "Bitmap already exists: %s", name
);
1719 if (s
->qcow_version
< 3) {
1720 /* Without autoclear_features, we would always have to assume
1721 * that a program without persistent dirty bitmap support has
1722 * accessed this qcow2 file when opening it, and would thus
1723 * have to drop all dirty bitmaps (defeating their purpose).
1725 error_setg(errp
, "Cannot store dirty bitmaps in qcow2 v2 files");
1729 if (check_constraints_on_bitmap(bs
, name
, granularity
, errp
) != 0) {
1733 FOR_EACH_DIRTY_BITMAP(bs
, bitmap
) {
1734 if (bdrv_dirty_bitmap_get_persistence(bitmap
)) {
1736 bitmap_directory_size
+=
1737 calc_dir_entry_size(strlen(bdrv_dirty_bitmap_name(bitmap
)), 0);
1741 bitmap_directory_size
+= calc_dir_entry_size(strlen(name
), 0);
1743 if (nb_bitmaps
> QCOW2_MAX_BITMAPS
) {
1745 "Maximum number of persistent bitmaps is already reached");
1749 if (bitmap_directory_size
> QCOW2_MAX_BITMAP_DIRECTORY_SIZE
) {
1750 error_setg(errp
, "Not enough space in the bitmap directory");
1757 error_prepend(errp
, "Can't make bitmap '%s' persistent in '%s': ",
1758 name
, bdrv_get_device_or_node_name(bs
));
1762 bool qcow2_supports_persistent_dirty_bitmap(BlockDriverState
*bs
)
1764 BDRVQcow2State
*s
= bs
->opaque
;
1766 return s
->qcow_version
>= 3;
1770 * Compute the space required to copy bitmaps from @in_bs.
1772 * The computation is based as if copying to a new image with the
1773 * given @cluster_size, which may differ from the cluster size in
1774 * @in_bs; in fact, @in_bs might be something other than qcow2.
1776 uint64_t qcow2_get_persistent_dirty_bitmap_size(BlockDriverState
*in_bs
,
1777 uint32_t cluster_size
)
1779 uint64_t bitmaps_size
= 0;
1780 BdrvDirtyBitmap
*bm
;
1781 size_t bitmap_dir_size
= 0;
1783 FOR_EACH_DIRTY_BITMAP(in_bs
, bm
) {
1784 if (bdrv_dirty_bitmap_get_persistence(bm
)) {
1785 const char *name
= bdrv_dirty_bitmap_name(bm
);
1786 uint32_t granularity
= bdrv_dirty_bitmap_granularity(bm
);
1788 get_bitmap_bytes_needed(bdrv_dirty_bitmap_size(bm
),
1790 uint64_t bmclusters
= DIV_ROUND_UP(bmbytes
, cluster_size
);
1792 /* Assume the entire bitmap is allocated */
1793 bitmaps_size
+= bmclusters
* cluster_size
;
1794 /* Also reserve space for the bitmap table entries */
1795 bitmaps_size
+= ROUND_UP(bmclusters
* BME_TABLE_ENTRY_SIZE
,
1797 /* And space for contribution to bitmap directory size */
1798 bitmap_dir_size
+= calc_dir_entry_size(strlen(name
), 0);
1801 bitmaps_size
+= ROUND_UP(bitmap_dir_size
, cluster_size
);
1803 return bitmaps_size
;