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 "qapi/error.h"
30 #include "qemu/cutils.h"
34 /* NOTICE: BME here means Bitmaps Extension and used as a namespace for
35 * _internal_ constants. Please do not use this _internal_ abbreviation for
36 * other needs and/or outside of this file. */
38 /* Bitmap directory entry constraints */
39 #define BME_MAX_TABLE_SIZE 0x8000000
40 #define BME_MAX_PHYS_SIZE 0x20000000 /* restrict BdrvDirtyBitmap size in RAM */
41 #define BME_MAX_GRANULARITY_BITS 31
42 #define BME_MIN_GRANULARITY_BITS 9
43 #define BME_MAX_NAME_SIZE 1023
45 #if BME_MAX_TABLE_SIZE * 8ULL > INT_MAX
46 #error In the code bitmap table physical size assumed to fit into int
49 /* Bitmap directory entry flags */
50 #define BME_RESERVED_FLAGS 0xfffffffcU
51 #define BME_FLAG_IN_USE (1U << 0)
52 #define BME_FLAG_AUTO (1U << 1)
54 /* bits [1, 8] U [56, 63] are reserved */
55 #define BME_TABLE_ENTRY_RESERVED_MASK 0xff000000000001feULL
56 #define BME_TABLE_ENTRY_OFFSET_MASK 0x00fffffffffffe00ULL
57 #define BME_TABLE_ENTRY_FLAG_ALL_ONES (1ULL << 0)
59 typedef struct QEMU_PACKED Qcow2BitmapDirEntry
{
60 /* header is 8 byte aligned */
61 uint64_t bitmap_table_offset
;
63 uint32_t bitmap_table_size
;
67 uint8_t granularity_bits
;
69 uint32_t extra_data_size
;
70 /* extra data follows */
72 } Qcow2BitmapDirEntry
;
74 typedef struct Qcow2BitmapTable
{
76 uint32_t size
; /* number of 64bit entries */
77 QSIMPLEQ_ENTRY(Qcow2BitmapTable
) entry
;
80 typedef struct Qcow2Bitmap
{
81 Qcow2BitmapTable table
;
83 uint8_t granularity_bits
;
86 BdrvDirtyBitmap
*dirty_bitmap
;
88 QSIMPLEQ_ENTRY(Qcow2Bitmap
) entry
;
90 typedef QSIMPLEQ_HEAD(Qcow2BitmapList
, Qcow2Bitmap
) Qcow2BitmapList
;
92 typedef enum BitmapType
{
93 BT_DIRTY_TRACKING_BITMAP
= 1
96 static inline bool can_write(BlockDriverState
*bs
)
98 return !bdrv_is_read_only(bs
) && !(bdrv_get_flags(bs
) & BDRV_O_INACTIVE
);
101 static int update_header_sync(BlockDriverState
*bs
)
105 ret
= qcow2_update_header(bs
);
110 return bdrv_flush(bs
->file
->bs
);
113 static inline void bitmap_table_to_be(uint64_t *bitmap_table
, size_t size
)
117 for (i
= 0; i
< size
; ++i
) {
118 bitmap_table
[i
] = cpu_to_be64(bitmap_table
[i
]);
122 static int check_table_entry(uint64_t entry
, int cluster_size
)
126 if (entry
& BME_TABLE_ENTRY_RESERVED_MASK
) {
130 offset
= entry
& BME_TABLE_ENTRY_OFFSET_MASK
;
132 /* if offset specified, bit 0 is reserved */
133 if (entry
& BME_TABLE_ENTRY_FLAG_ALL_ONES
) {
137 if (offset
% cluster_size
!= 0) {
145 static int64_t get_bitmap_bytes_needed(int64_t len
, uint32_t granularity
)
147 int64_t num_bits
= DIV_ROUND_UP(len
, granularity
);
149 return DIV_ROUND_UP(num_bits
, 8);
152 static int check_constraints_on_bitmap(BlockDriverState
*bs
,
154 uint32_t granularity
,
157 BDRVQcow2State
*s
= bs
->opaque
;
158 int granularity_bits
= ctz32(granularity
);
159 int64_t len
= bdrv_getlength(bs
);
160 int64_t bitmap_bytes
;
162 assert(granularity
> 0);
163 assert((granularity
& (granularity
- 1)) == 0);
166 error_setg_errno(errp
, -len
, "Failed to get size of '%s'",
167 bdrv_get_device_or_node_name(bs
));
171 if (granularity_bits
> BME_MAX_GRANULARITY_BITS
) {
172 error_setg(errp
, "Granularity exceeds maximum (%llu bytes)",
173 1ULL << BME_MAX_GRANULARITY_BITS
);
176 if (granularity_bits
< BME_MIN_GRANULARITY_BITS
) {
177 error_setg(errp
, "Granularity is under minimum (%llu bytes)",
178 1ULL << BME_MIN_GRANULARITY_BITS
);
182 bitmap_bytes
= get_bitmap_bytes_needed(len
, granularity
);
183 if ((bitmap_bytes
> (uint64_t)BME_MAX_PHYS_SIZE
) ||
184 (bitmap_bytes
> (uint64_t)BME_MAX_TABLE_SIZE
* s
->cluster_size
))
186 error_setg(errp
, "Too much space will be occupied by the bitmap. "
187 "Use larger granularity");
191 if (strlen(name
) > BME_MAX_NAME_SIZE
) {
192 error_setg(errp
, "Name length exceeds maximum (%u characters)",
200 static void clear_bitmap_table(BlockDriverState
*bs
, uint64_t *bitmap_table
,
201 uint32_t bitmap_table_size
)
203 BDRVQcow2State
*s
= bs
->opaque
;
206 for (i
= 0; i
< bitmap_table_size
; ++i
) {
207 uint64_t addr
= bitmap_table
[i
] & BME_TABLE_ENTRY_OFFSET_MASK
;
212 qcow2_free_clusters(bs
, addr
, s
->cluster_size
, QCOW2_DISCARD_ALWAYS
);
217 static int bitmap_table_load(BlockDriverState
*bs
, Qcow2BitmapTable
*tb
,
218 uint64_t **bitmap_table
)
221 BDRVQcow2State
*s
= bs
->opaque
;
225 assert(tb
->size
!= 0);
226 table
= g_try_new(uint64_t, tb
->size
);
231 assert(tb
->size
<= BME_MAX_TABLE_SIZE
);
232 ret
= bdrv_pread(bs
->file
, tb
->offset
,
233 table
, tb
->size
* sizeof(uint64_t));
238 for (i
= 0; i
< tb
->size
; ++i
) {
239 table
[i
] = be64_to_cpu(table
[i
]);
240 ret
= check_table_entry(table
[i
], s
->cluster_size
);
246 *bitmap_table
= table
;
255 static int free_bitmap_clusters(BlockDriverState
*bs
, Qcow2BitmapTable
*tb
)
258 uint64_t *bitmap_table
;
260 ret
= bitmap_table_load(bs
, tb
, &bitmap_table
);
265 clear_bitmap_table(bs
, bitmap_table
, tb
->size
);
266 qcow2_free_clusters(bs
, tb
->offset
, tb
->size
* sizeof(uint64_t),
267 QCOW2_DISCARD_OTHER
);
268 g_free(bitmap_table
);
276 /* Return the disk size covered by a single qcow2 cluster of bitmap data. */
277 static uint64_t bytes_covered_by_bitmap_cluster(const BDRVQcow2State
*s
,
278 const BdrvDirtyBitmap
*bitmap
)
280 uint64_t granularity
= bdrv_dirty_bitmap_granularity(bitmap
);
281 uint64_t limit
= granularity
* (s
->cluster_size
<< 3);
283 assert(QEMU_IS_ALIGNED(limit
,
284 bdrv_dirty_bitmap_serialization_align(bitmap
)));
289 * @bitmap_table entries must satisfy specification constraints.
290 * @bitmap must be cleared */
291 static int load_bitmap_data(BlockDriverState
*bs
,
292 const uint64_t *bitmap_table
,
293 uint32_t bitmap_table_size
,
294 BdrvDirtyBitmap
*bitmap
)
297 BDRVQcow2State
*s
= bs
->opaque
;
298 uint64_t offset
, limit
;
299 uint64_t bm_size
= bdrv_dirty_bitmap_size(bitmap
);
301 uint64_t i
, tab_size
=
303 bdrv_dirty_bitmap_serialization_size(bitmap
, 0, bm_size
));
305 if (tab_size
!= bitmap_table_size
|| tab_size
> BME_MAX_TABLE_SIZE
) {
309 buf
= g_malloc(s
->cluster_size
);
310 limit
= bytes_covered_by_bitmap_cluster(s
, bitmap
);
311 for (i
= 0, offset
= 0; i
< tab_size
; ++i
, offset
+= limit
) {
312 uint64_t count
= MIN(bm_size
- offset
, limit
);
313 uint64_t entry
= bitmap_table
[i
];
314 uint64_t data_offset
= entry
& BME_TABLE_ENTRY_OFFSET_MASK
;
316 assert(check_table_entry(entry
, s
->cluster_size
) == 0);
318 if (data_offset
== 0) {
319 if (entry
& BME_TABLE_ENTRY_FLAG_ALL_ONES
) {
320 bdrv_dirty_bitmap_deserialize_ones(bitmap
, offset
, count
,
323 /* No need to deserialize zeros because the dirty bitmap is
327 ret
= bdrv_pread(bs
->file
, data_offset
, buf
, s
->cluster_size
);
331 bdrv_dirty_bitmap_deserialize_part(bitmap
, buf
, offset
, count
,
337 bdrv_dirty_bitmap_deserialize_finish(bitmap
);
345 static BdrvDirtyBitmap
*load_bitmap(BlockDriverState
*bs
,
346 Qcow2Bitmap
*bm
, Error
**errp
)
349 uint64_t *bitmap_table
= NULL
;
350 uint32_t granularity
;
351 BdrvDirtyBitmap
*bitmap
= NULL
;
353 granularity
= 1U << bm
->granularity_bits
;
354 bitmap
= bdrv_create_dirty_bitmap(bs
, granularity
, bm
->name
, errp
);
355 if (bitmap
== NULL
) {
359 if (bm
->flags
& BME_FLAG_IN_USE
) {
360 /* Data is unusable, skip loading it */
364 ret
= bitmap_table_load(bs
, &bm
->table
, &bitmap_table
);
366 error_setg_errno(errp
, -ret
,
367 "Could not read bitmap_table table from image for "
368 "bitmap '%s'", bm
->name
);
372 ret
= load_bitmap_data(bs
, bitmap_table
, bm
->table
.size
, bitmap
);
374 error_setg_errno(errp
, -ret
, "Could not read bitmap '%s' from image",
379 g_free(bitmap_table
);
383 g_free(bitmap_table
);
384 if (bitmap
!= NULL
) {
385 bdrv_release_dirty_bitmap(bitmap
);
396 * Bitmap List private functions
397 * Only Bitmap List knows about bitmap directory structure in Qcow2.
400 static inline void bitmap_dir_entry_to_cpu(Qcow2BitmapDirEntry
*entry
)
402 entry
->bitmap_table_offset
= be64_to_cpu(entry
->bitmap_table_offset
);
403 entry
->bitmap_table_size
= be32_to_cpu(entry
->bitmap_table_size
);
404 entry
->flags
= be32_to_cpu(entry
->flags
);
405 entry
->name_size
= be16_to_cpu(entry
->name_size
);
406 entry
->extra_data_size
= be32_to_cpu(entry
->extra_data_size
);
409 static inline void bitmap_dir_entry_to_be(Qcow2BitmapDirEntry
*entry
)
411 entry
->bitmap_table_offset
= cpu_to_be64(entry
->bitmap_table_offset
);
412 entry
->bitmap_table_size
= cpu_to_be32(entry
->bitmap_table_size
);
413 entry
->flags
= cpu_to_be32(entry
->flags
);
414 entry
->name_size
= cpu_to_be16(entry
->name_size
);
415 entry
->extra_data_size
= cpu_to_be32(entry
->extra_data_size
);
418 static inline int calc_dir_entry_size(size_t name_size
, size_t extra_data_size
)
420 int size
= sizeof(Qcow2BitmapDirEntry
) + name_size
+ extra_data_size
;
421 return ROUND_UP(size
, 8);
424 static inline int dir_entry_size(Qcow2BitmapDirEntry
*entry
)
426 return calc_dir_entry_size(entry
->name_size
, entry
->extra_data_size
);
429 static inline const char *dir_entry_name_field(Qcow2BitmapDirEntry
*entry
)
431 return (const char *)(entry
+ 1) + entry
->extra_data_size
;
434 static inline char *dir_entry_copy_name(Qcow2BitmapDirEntry
*entry
)
436 const char *name_field
= dir_entry_name_field(entry
);
437 return g_strndup(name_field
, entry
->name_size
);
440 static inline Qcow2BitmapDirEntry
*next_dir_entry(Qcow2BitmapDirEntry
*entry
)
442 return (Qcow2BitmapDirEntry
*)((uint8_t *)entry
+ dir_entry_size(entry
));
445 static int check_dir_entry(BlockDriverState
*bs
, Qcow2BitmapDirEntry
*entry
)
447 BDRVQcow2State
*s
= bs
->opaque
;
448 uint64_t phys_bitmap_bytes
;
451 bool fail
= (entry
->bitmap_table_size
== 0) ||
452 (entry
->bitmap_table_offset
== 0) ||
453 (entry
->bitmap_table_offset
% s
->cluster_size
) ||
454 (entry
->bitmap_table_size
> BME_MAX_TABLE_SIZE
) ||
455 (entry
->granularity_bits
> BME_MAX_GRANULARITY_BITS
) ||
456 (entry
->granularity_bits
< BME_MIN_GRANULARITY_BITS
) ||
457 (entry
->flags
& BME_RESERVED_FLAGS
) ||
458 (entry
->name_size
> BME_MAX_NAME_SIZE
) ||
459 (entry
->type
!= BT_DIRTY_TRACKING_BITMAP
);
465 phys_bitmap_bytes
= (uint64_t)entry
->bitmap_table_size
* s
->cluster_size
;
466 len
= bdrv_getlength(bs
);
472 if (phys_bitmap_bytes
> BME_MAX_PHYS_SIZE
) {
476 if (!(entry
->flags
& BME_FLAG_IN_USE
) &&
477 (len
> ((phys_bitmap_bytes
* 8) << entry
->granularity_bits
)))
480 * We've loaded a valid bitmap (IN_USE not set) or we are going to
481 * store a valid bitmap, but the allocated bitmap table size is not
482 * enough to store this bitmap.
484 * Note, that it's OK to have an invalid bitmap with invalid size due
485 * to a bitmap that was not correctly saved after image resize.
493 static inline void bitmap_directory_to_be(uint8_t *dir
, size_t size
)
495 uint8_t *end
= dir
+ size
;
497 Qcow2BitmapDirEntry
*e
= (Qcow2BitmapDirEntry
*)dir
;
498 dir
+= dir_entry_size(e
);
500 bitmap_dir_entry_to_be(e
);
505 * Bitmap List public functions
508 static void bitmap_free(Qcow2Bitmap
*bm
)
518 static void bitmap_list_free(Qcow2BitmapList
*bm_list
)
522 if (bm_list
== NULL
) {
526 while ((bm
= QSIMPLEQ_FIRST(bm_list
)) != NULL
) {
527 QSIMPLEQ_REMOVE_HEAD(bm_list
, entry
);
534 static Qcow2BitmapList
*bitmap_list_new(void)
536 Qcow2BitmapList
*bm_list
= g_new(Qcow2BitmapList
, 1);
537 QSIMPLEQ_INIT(bm_list
);
542 static uint32_t bitmap_list_count(Qcow2BitmapList
*bm_list
)
545 uint32_t nb_bitmaps
= 0;
547 QSIMPLEQ_FOREACH(bm
, bm_list
, entry
) {
555 * Get bitmap list from qcow2 image. Actually reads bitmap directory,
556 * checks it and convert to bitmap list.
558 static Qcow2BitmapList
*bitmap_list_load(BlockDriverState
*bs
, uint64_t offset
,
559 uint64_t size
, Error
**errp
)
562 BDRVQcow2State
*s
= bs
->opaque
;
563 uint8_t *dir
, *dir_end
;
564 Qcow2BitmapDirEntry
*e
;
565 uint32_t nb_dir_entries
= 0;
566 Qcow2BitmapList
*bm_list
= NULL
;
569 error_setg(errp
, "Requested bitmap directory size is zero");
573 if (size
> QCOW2_MAX_BITMAP_DIRECTORY_SIZE
) {
574 error_setg(errp
, "Requested bitmap directory size is too big");
578 dir
= g_try_malloc(size
);
580 error_setg(errp
, "Failed to allocate space for bitmap directory");
583 dir_end
= dir
+ size
;
585 ret
= bdrv_pread(bs
->file
, offset
, dir
, size
);
587 error_setg_errno(errp
, -ret
, "Failed to read bitmap directory");
591 bm_list
= bitmap_list_new();
592 for (e
= (Qcow2BitmapDirEntry
*)dir
;
593 e
< (Qcow2BitmapDirEntry
*)dir_end
;
594 e
= next_dir_entry(e
))
598 if ((uint8_t *)(e
+ 1) > dir_end
) {
602 if (++nb_dir_entries
> s
->nb_bitmaps
) {
603 error_setg(errp
, "More bitmaps found than specified in header"
607 bitmap_dir_entry_to_cpu(e
);
609 if ((uint8_t *)next_dir_entry(e
) > dir_end
) {
613 if (e
->extra_data_size
!= 0) {
614 error_setg(errp
, "Bitmap extra data is not supported");
618 ret
= check_dir_entry(bs
, e
);
620 error_setg(errp
, "Bitmap '%.*s' doesn't satisfy the constraints",
621 e
->name_size
, dir_entry_name_field(e
));
625 bm
= g_new0(Qcow2Bitmap
, 1);
626 bm
->table
.offset
= e
->bitmap_table_offset
;
627 bm
->table
.size
= e
->bitmap_table_size
;
628 bm
->flags
= e
->flags
;
629 bm
->granularity_bits
= e
->granularity_bits
;
630 bm
->name
= dir_entry_copy_name(e
);
631 QSIMPLEQ_INSERT_TAIL(bm_list
, bm
, entry
);
634 if (nb_dir_entries
!= s
->nb_bitmaps
) {
635 error_setg(errp
, "Less bitmaps found than specified in header"
640 if ((uint8_t *)e
!= dir_end
) {
649 error_setg(errp
, "Broken bitmap directory");
653 bitmap_list_free(bm_list
);
658 int qcow2_check_bitmaps_refcounts(BlockDriverState
*bs
, BdrvCheckResult
*res
,
659 void **refcount_table
,
660 int64_t *refcount_table_size
)
663 BDRVQcow2State
*s
= bs
->opaque
;
664 Qcow2BitmapList
*bm_list
;
667 if (s
->nb_bitmaps
== 0) {
671 ret
= qcow2_inc_refcounts_imrt(bs
, res
, refcount_table
, refcount_table_size
,
672 s
->bitmap_directory_offset
,
673 s
->bitmap_directory_size
);
678 bm_list
= bitmap_list_load(bs
, s
->bitmap_directory_offset
,
679 s
->bitmap_directory_size
, NULL
);
680 if (bm_list
== NULL
) {
685 QSIMPLEQ_FOREACH(bm
, bm_list
, entry
) {
686 uint64_t *bitmap_table
= NULL
;
689 ret
= qcow2_inc_refcounts_imrt(bs
, res
,
690 refcount_table
, refcount_table_size
,
692 bm
->table
.size
* sizeof(uint64_t));
697 ret
= bitmap_table_load(bs
, &bm
->table
, &bitmap_table
);
703 for (i
= 0; i
< bm
->table
.size
; ++i
) {
704 uint64_t entry
= bitmap_table
[i
];
705 uint64_t offset
= entry
& BME_TABLE_ENTRY_OFFSET_MASK
;
707 if (check_table_entry(entry
, s
->cluster_size
) < 0) {
716 ret
= qcow2_inc_refcounts_imrt(bs
, res
,
717 refcount_table
, refcount_table_size
,
718 offset
, s
->cluster_size
);
720 g_free(bitmap_table
);
725 g_free(bitmap_table
);
729 bitmap_list_free(bm_list
);
735 * Store bitmap list to qcow2 image as a bitmap directory.
736 * Everything is checked.
738 static int bitmap_list_store(BlockDriverState
*bs
, Qcow2BitmapList
*bm_list
,
739 uint64_t *offset
, uint64_t *size
, bool in_place
)
743 int64_t dir_offset
= 0;
744 uint64_t dir_size
= 0;
746 Qcow2BitmapDirEntry
*e
;
748 QSIMPLEQ_FOREACH(bm
, bm_list
, entry
) {
749 dir_size
+= calc_dir_entry_size(strlen(bm
->name
), 0);
752 if (dir_size
== 0 || dir_size
> QCOW2_MAX_BITMAP_DIRECTORY_SIZE
) {
757 if (*size
!= dir_size
|| *offset
== 0) {
761 dir_offset
= *offset
;
764 dir
= g_try_malloc0(dir_size
);
769 e
= (Qcow2BitmapDirEntry
*)dir
;
770 QSIMPLEQ_FOREACH(bm
, bm_list
, entry
) {
771 e
->bitmap_table_offset
= bm
->table
.offset
;
772 e
->bitmap_table_size
= bm
->table
.size
;
773 e
->flags
= bm
->flags
;
774 e
->type
= BT_DIRTY_TRACKING_BITMAP
;
775 e
->granularity_bits
= bm
->granularity_bits
;
776 e
->name_size
= strlen(bm
->name
);
777 e
->extra_data_size
= 0;
778 memcpy(e
+ 1, bm
->name
, e
->name_size
);
780 if (check_dir_entry(bs
, e
) < 0) {
785 e
= next_dir_entry(e
);
788 bitmap_directory_to_be(dir
, dir_size
);
791 dir_offset
= qcow2_alloc_clusters(bs
, dir_size
);
792 if (dir_offset
< 0) {
798 /* Actually, even in in-place case ignoring QCOW2_OL_BITMAP_DIRECTORY is not
799 * necessary, because we drop QCOW2_AUTOCLEAR_BITMAPS when updating bitmap
800 * directory in-place (actually, turn-off the extension), which is checked
801 * in qcow2_check_metadata_overlap() */
802 ret
= qcow2_pre_write_overlap_check(
803 bs
, in_place
? QCOW2_OL_BITMAP_DIRECTORY
: 0, dir_offset
, dir_size
,
809 ret
= bdrv_pwrite(bs
->file
, dir_offset
, dir
, dir_size
);
818 *offset
= dir_offset
;
826 if (!in_place
&& dir_offset
> 0) {
827 qcow2_free_clusters(bs
, dir_offset
, dir_size
, QCOW2_DISCARD_OTHER
);
837 static int update_ext_header_and_dir_in_place(BlockDriverState
*bs
,
838 Qcow2BitmapList
*bm_list
)
840 BDRVQcow2State
*s
= bs
->opaque
;
843 if (!(s
->autoclear_features
& QCOW2_AUTOCLEAR_BITMAPS
) ||
844 bm_list
== NULL
|| QSIMPLEQ_EMPTY(bm_list
) ||
845 bitmap_list_count(bm_list
) != s
->nb_bitmaps
)
850 s
->autoclear_features
&= ~(uint64_t)QCOW2_AUTOCLEAR_BITMAPS
;
851 ret
= update_header_sync(bs
);
853 /* Two variants are possible here:
854 * 1. Autoclear flag is dropped, all bitmaps will be lost.
855 * 2. Autoclear flag is not dropped, old state is left.
860 /* autoclear bit is not set, so we can safely update bitmap directory */
862 ret
= bitmap_list_store(bs
, bm_list
, &s
->bitmap_directory_offset
,
863 &s
->bitmap_directory_size
, true);
865 /* autoclear bit is cleared, so all leaked clusters would be removed on
870 ret
= update_header_sync(bs
);
872 /* autoclear bit is cleared, so all leaked clusters would be removed on
877 s
->autoclear_features
|= QCOW2_AUTOCLEAR_BITMAPS
;
878 return update_header_sync(bs
);
879 /* If final update_header_sync() fails, two variants are possible:
880 * 1. Autoclear flag is not set, all bitmaps will be lost.
881 * 2. Autoclear flag is set, header and directory are successfully updated.
885 static int update_ext_header_and_dir(BlockDriverState
*bs
,
886 Qcow2BitmapList
*bm_list
)
888 BDRVQcow2State
*s
= bs
->opaque
;
890 uint64_t new_offset
= 0;
891 uint64_t new_size
= 0;
892 uint32_t new_nb_bitmaps
= 0;
893 uint64_t old_offset
= s
->bitmap_directory_offset
;
894 uint64_t old_size
= s
->bitmap_directory_size
;
895 uint32_t old_nb_bitmaps
= s
->nb_bitmaps
;
896 uint64_t old_autocl
= s
->autoclear_features
;
898 if (bm_list
!= NULL
&& !QSIMPLEQ_EMPTY(bm_list
)) {
899 new_nb_bitmaps
= bitmap_list_count(bm_list
);
901 if (new_nb_bitmaps
> QCOW2_MAX_BITMAPS
) {
905 ret
= bitmap_list_store(bs
, bm_list
, &new_offset
, &new_size
, false);
910 ret
= qcow2_flush_caches(bs
);
915 s
->autoclear_features
|= QCOW2_AUTOCLEAR_BITMAPS
;
917 s
->autoclear_features
&= ~(uint64_t)QCOW2_AUTOCLEAR_BITMAPS
;
920 s
->bitmap_directory_offset
= new_offset
;
921 s
->bitmap_directory_size
= new_size
;
922 s
->nb_bitmaps
= new_nb_bitmaps
;
924 ret
= update_header_sync(bs
);
930 qcow2_free_clusters(bs
, old_offset
, old_size
, QCOW2_DISCARD_OTHER
);
936 if (new_offset
> 0) {
937 qcow2_free_clusters(bs
, new_offset
, new_size
, QCOW2_DISCARD_OTHER
);
940 s
->bitmap_directory_offset
= old_offset
;
941 s
->bitmap_directory_size
= old_size
;
942 s
->nb_bitmaps
= old_nb_bitmaps
;
943 s
->autoclear_features
= old_autocl
;
948 /* for g_slist_foreach for GSList of BdrvDirtyBitmap* elements */
949 static void release_dirty_bitmap_helper(gpointer bitmap
,
952 bdrv_release_dirty_bitmap(bitmap
);
955 /* for g_slist_foreach for GSList of BdrvDirtyBitmap* elements */
956 static void set_readonly_helper(gpointer bitmap
, gpointer value
)
958 bdrv_dirty_bitmap_set_readonly(bitmap
, (bool)value
);
961 /* qcow2_load_dirty_bitmaps()
962 * Return value is a hint for caller: true means that the Qcow2 header was
963 * updated. (false doesn't mean that the header should be updated by the
964 * caller, it just means that updating was not needed or the image cannot be
966 * On failure the function returns false.
968 bool qcow2_load_dirty_bitmaps(BlockDriverState
*bs
, Error
**errp
)
970 BDRVQcow2State
*s
= bs
->opaque
;
971 Qcow2BitmapList
*bm_list
;
973 GSList
*created_dirty_bitmaps
= NULL
;
974 bool header_updated
= false;
975 bool needs_update
= 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
= load_bitmap(bs
, bm
, errp
);
990 if (bitmap
== NULL
) {
994 bdrv_dirty_bitmap_set_persistence(bitmap
, true);
995 if (bm
->flags
& BME_FLAG_IN_USE
) {
996 bdrv_dirty_bitmap_set_inconsistent(bitmap
);
998 /* NB: updated flags only get written if can_write(bs) is true. */
999 bm
->flags
|= BME_FLAG_IN_USE
;
1000 needs_update
= true;
1002 if (!(bm
->flags
& BME_FLAG_AUTO
)) {
1003 bdrv_disable_dirty_bitmap(bitmap
);
1005 created_dirty_bitmaps
=
1006 g_slist_append(created_dirty_bitmaps
, bitmap
);
1009 if (needs_update
&& can_write(bs
)) {
1010 /* in_use flags must be updated */
1011 int ret
= update_ext_header_and_dir_in_place(bs
, bm_list
);
1013 error_setg_errno(errp
, -ret
, "Can't update bitmap directory");
1016 header_updated
= true;
1019 if (!can_write(bs
)) {
1020 g_slist_foreach(created_dirty_bitmaps
, set_readonly_helper
,
1024 g_slist_free(created_dirty_bitmaps
);
1025 bitmap_list_free(bm_list
);
1027 return header_updated
;
1030 g_slist_foreach(created_dirty_bitmaps
, release_dirty_bitmap_helper
, bs
);
1031 g_slist_free(created_dirty_bitmaps
);
1032 bitmap_list_free(bm_list
);
1038 static Qcow2BitmapInfoFlagsList
*get_bitmap_info_flags(uint32_t flags
)
1040 Qcow2BitmapInfoFlagsList
*list
= NULL
;
1041 Qcow2BitmapInfoFlagsList
**plist
= &list
;
1044 static const struct {
1045 int bme
; /* Bitmap directory entry flags */
1046 int info
; /* The flags to report to the user */
1048 { BME_FLAG_IN_USE
, QCOW2_BITMAP_INFO_FLAGS_IN_USE
},
1049 { BME_FLAG_AUTO
, QCOW2_BITMAP_INFO_FLAGS_AUTO
},
1052 int map_size
= ARRAY_SIZE(map
);
1054 for (i
= 0; i
< map_size
; ++i
) {
1055 if (flags
& map
[i
].bme
) {
1056 Qcow2BitmapInfoFlagsList
*entry
=
1057 g_new0(Qcow2BitmapInfoFlagsList
, 1);
1058 entry
->value
= map
[i
].info
;
1060 plist
= &entry
->next
;
1061 flags
&= ~map
[i
].bme
;
1064 /* Check if the BME_* mapping above is complete */
1071 * qcow2_get_bitmap_info_list()
1072 * Returns a list of QCOW2 bitmap details.
1073 * In case of no bitmaps, the function returns NULL and
1074 * the @errp parameter is not set.
1075 * When bitmap information can not be obtained, the function returns
1076 * NULL and the @errp parameter is set.
1078 Qcow2BitmapInfoList
*qcow2_get_bitmap_info_list(BlockDriverState
*bs
,
1081 BDRVQcow2State
*s
= bs
->opaque
;
1082 Qcow2BitmapList
*bm_list
;
1084 Qcow2BitmapInfoList
*list
= NULL
;
1085 Qcow2BitmapInfoList
**plist
= &list
;
1087 if (s
->nb_bitmaps
== 0) {
1091 bm_list
= bitmap_list_load(bs
, s
->bitmap_directory_offset
,
1092 s
->bitmap_directory_size
, errp
);
1093 if (bm_list
== NULL
) {
1097 QSIMPLEQ_FOREACH(bm
, bm_list
, entry
) {
1098 Qcow2BitmapInfo
*info
= g_new0(Qcow2BitmapInfo
, 1);
1099 Qcow2BitmapInfoList
*obj
= g_new0(Qcow2BitmapInfoList
, 1);
1100 info
->granularity
= 1U << bm
->granularity_bits
;
1101 info
->name
= g_strdup(bm
->name
);
1102 info
->flags
= get_bitmap_info_flags(bm
->flags
& ~BME_RESERVED_FLAGS
);
1108 bitmap_list_free(bm_list
);
1113 int qcow2_reopen_bitmaps_rw(BlockDriverState
*bs
, Error
**errp
)
1115 BDRVQcow2State
*s
= bs
->opaque
;
1116 Qcow2BitmapList
*bm_list
;
1118 GSList
*ro_dirty_bitmaps
= NULL
;
1120 bool need_header_update
= false;
1122 if (s
->nb_bitmaps
== 0) {
1123 /* No bitmaps - nothing to do */
1127 bm_list
= bitmap_list_load(bs
, s
->bitmap_directory_offset
,
1128 s
->bitmap_directory_size
, errp
);
1129 if (bm_list
== NULL
) {
1133 QSIMPLEQ_FOREACH(bm
, bm_list
, entry
) {
1134 BdrvDirtyBitmap
*bitmap
= bdrv_find_dirty_bitmap(bs
, bm
->name
);
1137 error_setg(errp
, "Unexpected bitmap '%s' in image '%s'",
1138 bm
->name
, bs
->filename
);
1142 if (!(bm
->flags
& BME_FLAG_IN_USE
)) {
1143 if (!bdrv_dirty_bitmap_readonly(bitmap
)) {
1144 error_setg(errp
, "Corruption: bitmap '%s' is not marked IN_USE "
1145 "in the image '%s' and not marked readonly in RAM",
1146 bm
->name
, bs
->filename
);
1149 if (bdrv_dirty_bitmap_inconsistent(bitmap
)) {
1150 error_setg(errp
, "Corruption: bitmap '%s' is inconsistent but "
1151 "is not marked IN_USE in the image '%s'", bm
->name
,
1156 bm
->flags
|= BME_FLAG_IN_USE
;
1157 need_header_update
= true;
1160 * What if flags already has BME_FLAG_IN_USE ?
1162 * 1. if we are reopening RW -> RW it's OK, of course.
1163 * 2. if we are reopening RO -> RW:
1164 * 2.1 if @bitmap is inconsistent, it's OK. It means that it was
1165 * inconsistent (IN_USE) when we loaded it
1166 * 2.2 if @bitmap is not inconsistent. This seems to be impossible
1167 * and implies third party interaction. Let's error-out for
1170 if (bdrv_dirty_bitmap_readonly(bitmap
) &&
1171 !bdrv_dirty_bitmap_inconsistent(bitmap
))
1173 error_setg(errp
, "Corruption: bitmap '%s' is marked IN_USE "
1174 "in the image '%s' but it is readonly and "
1175 "consistent in RAM",
1176 bm
->name
, bs
->filename
);
1181 if (bdrv_dirty_bitmap_readonly(bitmap
)) {
1182 ro_dirty_bitmaps
= g_slist_append(ro_dirty_bitmaps
, bitmap
);
1186 if (need_header_update
) {
1187 if (!can_write(bs
->file
->bs
) || !(bs
->file
->perm
& BLK_PERM_WRITE
)) {
1188 error_setg(errp
, "Failed to reopen bitmaps rw: no write access "
1189 "the protocol file");
1193 /* in_use flags must be updated */
1194 ret
= update_ext_header_and_dir_in_place(bs
, bm_list
);
1196 error_setg_errno(errp
, -ret
, "Cannot update bitmap directory");
1201 g_slist_foreach(ro_dirty_bitmaps
, set_readonly_helper
, false);
1205 g_slist_free(ro_dirty_bitmaps
);
1206 bitmap_list_free(bm_list
);
1211 /* Checks to see if it's safe to resize bitmaps */
1212 int qcow2_truncate_bitmaps_check(BlockDriverState
*bs
, Error
**errp
)
1214 BDRVQcow2State
*s
= bs
->opaque
;
1215 Qcow2BitmapList
*bm_list
;
1219 if (s
->nb_bitmaps
== 0) {
1223 bm_list
= bitmap_list_load(bs
, s
->bitmap_directory_offset
,
1224 s
->bitmap_directory_size
, errp
);
1225 if (bm_list
== NULL
) {
1229 QSIMPLEQ_FOREACH(bm
, bm_list
, entry
) {
1230 BdrvDirtyBitmap
*bitmap
= bdrv_find_dirty_bitmap(bs
, bm
->name
);
1231 if (bitmap
== NULL
) {
1233 * We rely on all bitmaps being in-memory to be able to resize them,
1234 * Otherwise, we'd need to resize them on disk explicitly
1236 error_setg(errp
, "Cannot resize qcow2 with persistent bitmaps that "
1237 "were not loaded into memory");
1243 * The checks against readonly and busy are redundant, but certainly
1244 * do no harm. checks against inconsistent are crucial:
1246 if (bdrv_dirty_bitmap_check(bitmap
, BDRV_BITMAP_DEFAULT
, errp
)) {
1253 bitmap_list_free(bm_list
);
1257 /* store_bitmap_data()
1258 * Store bitmap to image, filling bitmap table accordingly.
1260 static uint64_t *store_bitmap_data(BlockDriverState
*bs
,
1261 BdrvDirtyBitmap
*bitmap
,
1262 uint32_t *bitmap_table_size
, Error
**errp
)
1265 BDRVQcow2State
*s
= bs
->opaque
;
1268 uint64_t bm_size
= bdrv_dirty_bitmap_size(bitmap
);
1269 const char *bm_name
= bdrv_dirty_bitmap_name(bitmap
);
1270 uint8_t *buf
= NULL
;
1271 BdrvDirtyBitmapIter
*dbi
;
1275 bdrv_dirty_bitmap_serialization_size(bitmap
, 0, bm_size
));
1277 if (tb_size
> BME_MAX_TABLE_SIZE
||
1278 tb_size
* s
->cluster_size
> BME_MAX_PHYS_SIZE
)
1280 error_setg(errp
, "Bitmap '%s' is too big", bm_name
);
1284 tb
= g_try_new0(uint64_t, tb_size
);
1286 error_setg(errp
, "No memory");
1290 dbi
= bdrv_dirty_iter_new(bitmap
);
1291 buf
= g_malloc(s
->cluster_size
);
1292 limit
= bytes_covered_by_bitmap_cluster(s
, bitmap
);
1293 assert(DIV_ROUND_UP(bm_size
, limit
) == tb_size
);
1295 while ((offset
= bdrv_dirty_iter_next(dbi
)) >= 0) {
1296 uint64_t cluster
= offset
/ limit
;
1297 uint64_t end
, write_size
;
1301 * We found the first dirty offset, but want to write out the
1302 * entire cluster of the bitmap that includes that offset,
1303 * including any leading zero bits.
1305 offset
= QEMU_ALIGN_DOWN(offset
, limit
);
1306 end
= MIN(bm_size
, offset
+ limit
);
1307 write_size
= bdrv_dirty_bitmap_serialization_size(bitmap
, offset
,
1309 assert(write_size
<= s
->cluster_size
);
1311 off
= qcow2_alloc_clusters(bs
, s
->cluster_size
);
1313 error_setg_errno(errp
, -off
,
1314 "Failed to allocate clusters for bitmap '%s'",
1320 bdrv_dirty_bitmap_serialize_part(bitmap
, buf
, offset
, end
- offset
);
1321 if (write_size
< s
->cluster_size
) {
1322 memset(buf
+ write_size
, 0, s
->cluster_size
- write_size
);
1325 ret
= qcow2_pre_write_overlap_check(bs
, 0, off
, s
->cluster_size
, false);
1327 error_setg_errno(errp
, -ret
, "Qcow2 overlap check failed");
1331 ret
= bdrv_pwrite(bs
->file
, off
, buf
, s
->cluster_size
);
1333 error_setg_errno(errp
, -ret
, "Failed to write bitmap '%s' to file",
1338 if (end
>= bm_size
) {
1342 bdrv_set_dirty_iter(dbi
, end
);
1345 *bitmap_table_size
= tb_size
;
1347 bdrv_dirty_iter_free(dbi
);
1352 clear_bitmap_table(bs
, tb
, tb_size
);
1354 bdrv_dirty_iter_free(dbi
);
1361 * Store bm->dirty_bitmap to qcow2.
1362 * Set bm->table_offset and bm->table_size accordingly.
1364 static int store_bitmap(BlockDriverState
*bs
, Qcow2Bitmap
*bm
, Error
**errp
)
1370 BdrvDirtyBitmap
*bitmap
= bm
->dirty_bitmap
;
1371 const char *bm_name
;
1373 assert(bitmap
!= NULL
);
1375 bm_name
= bdrv_dirty_bitmap_name(bitmap
);
1377 tb
= store_bitmap_data(bs
, bitmap
, &tb_size
, errp
);
1382 assert(tb_size
<= BME_MAX_TABLE_SIZE
);
1383 tb_offset
= qcow2_alloc_clusters(bs
, tb_size
* sizeof(tb
[0]));
1384 if (tb_offset
< 0) {
1385 error_setg_errno(errp
, -tb_offset
,
1386 "Failed to allocate clusters for bitmap '%s'",
1392 ret
= qcow2_pre_write_overlap_check(bs
, 0, tb_offset
,
1393 tb_size
* sizeof(tb
[0]), false);
1395 error_setg_errno(errp
, -ret
, "Qcow2 overlap check failed");
1399 bitmap_table_to_be(tb
, tb_size
);
1400 ret
= bdrv_pwrite(bs
->file
, tb_offset
, tb
, tb_size
* sizeof(tb
[0]));
1402 error_setg_errno(errp
, -ret
, "Failed to write bitmap '%s' to file",
1409 bm
->table
.offset
= tb_offset
;
1410 bm
->table
.size
= tb_size
;
1415 clear_bitmap_table(bs
, tb
, tb_size
);
1417 if (tb_offset
> 0) {
1418 qcow2_free_clusters(bs
, tb_offset
, tb_size
* sizeof(tb
[0]),
1419 QCOW2_DISCARD_OTHER
);
1427 static Qcow2Bitmap
*find_bitmap_by_name(Qcow2BitmapList
*bm_list
,
1432 QSIMPLEQ_FOREACH(bm
, bm_list
, entry
) {
1433 if (strcmp(name
, bm
->name
) == 0) {
1441 int coroutine_fn
qcow2_co_remove_persistent_dirty_bitmap(BlockDriverState
*bs
,
1446 BDRVQcow2State
*s
= bs
->opaque
;
1447 Qcow2Bitmap
*bm
= NULL
;
1448 Qcow2BitmapList
*bm_list
;
1450 if (s
->nb_bitmaps
== 0) {
1451 /* Absence of the bitmap is not an error: see explanation above
1452 * bdrv_remove_persistent_dirty_bitmap() definition. */
1456 qemu_co_mutex_lock(&s
->lock
);
1458 bm_list
= bitmap_list_load(bs
, s
->bitmap_directory_offset
,
1459 s
->bitmap_directory_size
, errp
);
1460 if (bm_list
== NULL
) {
1465 bm
= find_bitmap_by_name(bm_list
, name
);
1471 QSIMPLEQ_REMOVE(bm_list
, bm
, Qcow2Bitmap
, entry
);
1473 ret
= update_ext_header_and_dir(bs
, bm_list
);
1475 error_setg_errno(errp
, -ret
, "Failed to update bitmap extension");
1479 free_bitmap_clusters(bs
, &bm
->table
);
1482 qemu_co_mutex_unlock(&s
->lock
);
1485 bitmap_list_free(bm_list
);
1491 * qcow2_store_persistent_dirty_bitmaps
1493 * Stores persistent BdrvDirtyBitmap objects.
1495 * @release_stored: if true, release BdrvDirtyBitmap's after storing to the
1496 * image. This is used in two cases, both via qcow2_inactivate:
1497 * 1. bdrv_close: It's correct to remove bitmaps on close.
1498 * 2. migration: If bitmaps are migrated through migration channel via
1499 * 'dirty-bitmaps' migration capability they are not handled by this code.
1500 * Otherwise, it's OK to drop BdrvDirtyBitmap's and reload them on
1503 * Anyway, it's correct to remove BdrvDirtyBitmap's on inactivation, as
1504 * inactivation means that we lose control on disk, and therefore on bitmaps,
1505 * we should sync them and do not touch more.
1507 * Contrariwise, we don't want to release any bitmaps on just reopen-to-ro,
1508 * when we need to store them, as image is still under our control, and it's
1509 * good to keep all the bitmaps in read-only mode. Moreover, keeping them
1510 * read-only is correct because this is what would happen if we opened the node
1511 * readonly to begin with, and whether we opened directly or reopened to that
1512 * state shouldn't matter for the state we get afterward.
1514 void qcow2_store_persistent_dirty_bitmaps(BlockDriverState
*bs
,
1515 bool release_stored
, Error
**errp
)
1517 BdrvDirtyBitmap
*bitmap
;
1518 BDRVQcow2State
*s
= bs
->opaque
;
1519 uint32_t new_nb_bitmaps
= s
->nb_bitmaps
;
1520 uint64_t new_dir_size
= s
->bitmap_directory_size
;
1522 Qcow2BitmapList
*bm_list
;
1524 QSIMPLEQ_HEAD(, Qcow2BitmapTable
) drop_tables
;
1525 Qcow2BitmapTable
*tb
, *tb_next
;
1526 bool need_write
= false;
1528 QSIMPLEQ_INIT(&drop_tables
);
1530 if (s
->nb_bitmaps
== 0) {
1531 bm_list
= bitmap_list_new();
1533 bm_list
= bitmap_list_load(bs
, s
->bitmap_directory_offset
,
1534 s
->bitmap_directory_size
, errp
);
1535 if (bm_list
== NULL
) {
1540 /* check constraints and names */
1541 FOR_EACH_DIRTY_BITMAP(bs
, bitmap
) {
1542 const char *name
= bdrv_dirty_bitmap_name(bitmap
);
1543 uint32_t granularity
= bdrv_dirty_bitmap_granularity(bitmap
);
1546 if (!bdrv_dirty_bitmap_get_persistence(bitmap
) ||
1547 bdrv_dirty_bitmap_readonly(bitmap
) ||
1548 bdrv_dirty_bitmap_inconsistent(bitmap
)) {
1554 if (check_constraints_on_bitmap(bs
, name
, granularity
, errp
) < 0) {
1555 error_prepend(errp
, "Bitmap '%s' doesn't satisfy the constraints: ",
1560 bm
= find_bitmap_by_name(bm_list
, name
);
1562 if (++new_nb_bitmaps
> QCOW2_MAX_BITMAPS
) {
1563 error_setg(errp
, "Too many persistent bitmaps");
1567 new_dir_size
+= calc_dir_entry_size(strlen(name
), 0);
1568 if (new_dir_size
> QCOW2_MAX_BITMAP_DIRECTORY_SIZE
) {
1569 error_setg(errp
, "Bitmap directory is too large");
1573 bm
= g_new0(Qcow2Bitmap
, 1);
1574 bm
->name
= g_strdup(name
);
1575 QSIMPLEQ_INSERT_TAIL(bm_list
, bm
, entry
);
1577 if (!(bm
->flags
& BME_FLAG_IN_USE
)) {
1578 error_setg(errp
, "Bitmap '%s' already exists in the image",
1582 tb
= g_memdup(&bm
->table
, sizeof(bm
->table
));
1583 bm
->table
.offset
= 0;
1585 QSIMPLEQ_INSERT_TAIL(&drop_tables
, tb
, entry
);
1587 bm
->flags
= bdrv_dirty_bitmap_enabled(bitmap
) ? BME_FLAG_AUTO
: 0;
1588 bm
->granularity_bits
= ctz32(bdrv_dirty_bitmap_granularity(bitmap
));
1589 bm
->dirty_bitmap
= bitmap
;
1596 if (!can_write(bs
)) {
1597 error_setg(errp
, "No write access");
1601 /* allocate clusters and store bitmaps */
1602 QSIMPLEQ_FOREACH(bm
, bm_list
, entry
) {
1603 if (bm
->dirty_bitmap
== NULL
) {
1607 ret
= store_bitmap(bs
, bm
, errp
);
1613 ret
= update_ext_header_and_dir(bs
, bm_list
);
1615 error_setg_errno(errp
, -ret
, "Failed to update bitmap extension");
1619 /* Bitmap directory was successfully updated, so, old data can be dropped.
1620 * TODO it is better to reuse these clusters */
1621 QSIMPLEQ_FOREACH_SAFE(tb
, &drop_tables
, entry
, tb_next
) {
1622 free_bitmap_clusters(bs
, tb
);
1626 if (release_stored
) {
1627 QSIMPLEQ_FOREACH(bm
, bm_list
, entry
) {
1628 if (bm
->dirty_bitmap
== NULL
) {
1632 bdrv_release_dirty_bitmap(bm
->dirty_bitmap
);
1637 bitmap_list_free(bm_list
);
1641 QSIMPLEQ_FOREACH(bm
, bm_list
, entry
) {
1642 if (bm
->dirty_bitmap
== NULL
|| bm
->table
.offset
== 0) {
1646 free_bitmap_clusters(bs
, &bm
->table
);
1649 QSIMPLEQ_FOREACH_SAFE(tb
, &drop_tables
, entry
, tb_next
) {
1653 bitmap_list_free(bm_list
);
1656 int qcow2_reopen_bitmaps_ro(BlockDriverState
*bs
, Error
**errp
)
1658 BdrvDirtyBitmap
*bitmap
;
1659 Error
*local_err
= NULL
;
1661 qcow2_store_persistent_dirty_bitmaps(bs
, false, &local_err
);
1662 if (local_err
!= NULL
) {
1663 error_propagate(errp
, local_err
);
1667 FOR_EACH_DIRTY_BITMAP(bs
, bitmap
) {
1668 if (bdrv_dirty_bitmap_get_persistence(bitmap
)) {
1669 bdrv_dirty_bitmap_set_readonly(bitmap
, true);
1676 bool coroutine_fn
qcow2_co_can_store_new_dirty_bitmap(BlockDriverState
*bs
,
1678 uint32_t granularity
,
1681 BDRVQcow2State
*s
= bs
->opaque
;
1683 Qcow2BitmapList
*bm_list
;
1685 if (s
->qcow_version
< 3) {
1686 /* Without autoclear_features, we would always have to assume
1687 * that a program without persistent dirty bitmap support has
1688 * accessed this qcow2 file when opening it, and would thus
1689 * have to drop all dirty bitmaps (defeating their purpose).
1691 error_setg(errp
, "Cannot store dirty bitmaps in qcow2 v2 files");
1695 if (check_constraints_on_bitmap(bs
, name
, granularity
, errp
) != 0) {
1699 if (s
->nb_bitmaps
== 0) {
1703 if (s
->nb_bitmaps
>= QCOW2_MAX_BITMAPS
) {
1705 "Maximum number of persistent bitmaps is already reached");
1709 if (s
->bitmap_directory_size
+ calc_dir_entry_size(strlen(name
), 0) >
1710 QCOW2_MAX_BITMAP_DIRECTORY_SIZE
)
1712 error_setg(errp
, "Not enough space in the bitmap directory");
1716 qemu_co_mutex_lock(&s
->lock
);
1717 bm_list
= bitmap_list_load(bs
, s
->bitmap_directory_offset
,
1718 s
->bitmap_directory_size
, errp
);
1719 qemu_co_mutex_unlock(&s
->lock
);
1720 if (bm_list
== NULL
) {
1724 found
= find_bitmap_by_name(bm_list
, name
);
1725 bitmap_list_free(bm_list
);
1727 error_setg(errp
, "Bitmap with the same name is already stored");
1734 error_prepend(errp
, "Can't make bitmap '%s' persistent in '%s': ",
1735 name
, bdrv_get_device_or_node_name(bs
));