4 * Copyright (c) 2016-2017 Red Hat. Inc
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 #include "qemu/osdep.h"
25 #include "qapi/error.h"
26 #include "qemu-common.h"
28 #include "block/block_int.h"
29 #include "block/blockjob.h"
32 * A BdrvDirtyBitmap can be in four possible user-visible states:
33 * (1) Active: successor is NULL, and disabled is false: full r/w mode
34 * (2) Disabled: successor is NULL, and disabled is true: qualified r/w mode,
35 * guest writes are dropped, but monitor writes are possible,
36 * through commands like merge and clear.
37 * (3) Frozen: successor is not NULL.
38 * A frozen bitmap cannot be renamed, deleted, cleared, set,
39 * enabled, merged to, etc. A frozen bitmap can only abdicate()
41 * In this state, the anonymous successor bitmap may be either
42 * Active and recording writes from the guest (e.g. backup jobs),
43 * but it can be Disabled and not recording writes.
44 * (4) Locked: Whether Active or Disabled, the user cannot modify this bitmap
45 * in any way from the monitor.
47 struct BdrvDirtyBitmap
{
49 HBitmap
*bitmap
; /* Dirty bitmap implementation */
50 HBitmap
*meta
; /* Meta dirty bitmap */
51 bool qmp_locked
; /* Bitmap is locked, it can't be modified
53 BdrvDirtyBitmap
*successor
; /* Anonymous child; implies user_locked state */
54 char *name
; /* Optional non-empty unique ID */
55 int64_t size
; /* Size of the bitmap, in bytes */
56 bool disabled
; /* Bitmap is disabled. It ignores all writes to
58 int active_iterators
; /* How many iterators are active */
59 bool readonly
; /* Bitmap is read-only. This field also
60 prevents the respective image from being
61 modified (i.e. blocks writes and discards).
62 Such operations must fail and both the image
63 and this bitmap must remain unchanged while
65 bool persistent
; /* bitmap must be saved to owner disk image */
66 bool migration
; /* Bitmap is selected for migration, it should
67 not be stored on the next inactivation
68 (persistent flag doesn't matter until next
70 QLIST_ENTRY(BdrvDirtyBitmap
) list
;
73 struct BdrvDirtyBitmapIter
{
75 BdrvDirtyBitmap
*bitmap
;
78 static inline void bdrv_dirty_bitmaps_lock(BlockDriverState
*bs
)
80 qemu_mutex_lock(&bs
->dirty_bitmap_mutex
);
83 static inline void bdrv_dirty_bitmaps_unlock(BlockDriverState
*bs
)
85 qemu_mutex_unlock(&bs
->dirty_bitmap_mutex
);
88 void bdrv_dirty_bitmap_lock(BdrvDirtyBitmap
*bitmap
)
90 qemu_mutex_lock(bitmap
->mutex
);
93 void bdrv_dirty_bitmap_unlock(BdrvDirtyBitmap
*bitmap
)
95 qemu_mutex_unlock(bitmap
->mutex
);
98 /* Called with BQL or dirty_bitmap lock taken. */
99 BdrvDirtyBitmap
*bdrv_find_dirty_bitmap(BlockDriverState
*bs
, const char *name
)
104 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
105 if (bm
->name
&& !strcmp(name
, bm
->name
)) {
112 /* Called with BQL taken. */
113 BdrvDirtyBitmap
*bdrv_create_dirty_bitmap(BlockDriverState
*bs
,
114 uint32_t granularity
,
119 BdrvDirtyBitmap
*bitmap
;
121 assert(is_power_of_2(granularity
) && granularity
>= BDRV_SECTOR_SIZE
);
123 if (name
&& bdrv_find_dirty_bitmap(bs
, name
)) {
124 error_setg(errp
, "Bitmap already exists: %s", name
);
127 bitmap_size
= bdrv_getlength(bs
);
128 if (bitmap_size
< 0) {
129 error_setg_errno(errp
, -bitmap_size
, "could not get length of device");
130 errno
= -bitmap_size
;
133 bitmap
= g_new0(BdrvDirtyBitmap
, 1);
134 bitmap
->mutex
= &bs
->dirty_bitmap_mutex
;
135 bitmap
->bitmap
= hbitmap_alloc(bitmap_size
, ctz32(granularity
));
136 bitmap
->size
= bitmap_size
;
137 bitmap
->name
= g_strdup(name
);
138 bitmap
->disabled
= false;
139 bdrv_dirty_bitmaps_lock(bs
);
140 QLIST_INSERT_HEAD(&bs
->dirty_bitmaps
, bitmap
, list
);
141 bdrv_dirty_bitmaps_unlock(bs
);
145 /* bdrv_create_meta_dirty_bitmap
147 * Create a meta dirty bitmap that tracks the changes of bits in @bitmap. I.e.
148 * when a dirty status bit in @bitmap is changed (either from reset to set or
149 * the other way around), its respective meta dirty bitmap bit will be marked
152 * @bitmap: the block dirty bitmap for which to create a meta dirty bitmap.
153 * @chunk_size: how many bytes of bitmap data does each bit in the meta bitmap
156 void bdrv_create_meta_dirty_bitmap(BdrvDirtyBitmap
*bitmap
,
159 assert(!bitmap
->meta
);
160 qemu_mutex_lock(bitmap
->mutex
);
161 bitmap
->meta
= hbitmap_create_meta(bitmap
->bitmap
,
162 chunk_size
* BITS_PER_BYTE
);
163 qemu_mutex_unlock(bitmap
->mutex
);
166 void bdrv_release_meta_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
168 assert(bitmap
->meta
);
169 qemu_mutex_lock(bitmap
->mutex
);
170 hbitmap_free_meta(bitmap
->bitmap
);
172 qemu_mutex_unlock(bitmap
->mutex
);
175 int64_t bdrv_dirty_bitmap_size(const BdrvDirtyBitmap
*bitmap
)
180 const char *bdrv_dirty_bitmap_name(const BdrvDirtyBitmap
*bitmap
)
185 /* Called with BQL taken. */
186 bool bdrv_dirty_bitmap_has_successor(BdrvDirtyBitmap
*bitmap
)
188 return bitmap
->successor
;
191 /* Both conditions disallow user-modification via QMP. */
192 bool bdrv_dirty_bitmap_user_locked(BdrvDirtyBitmap
*bitmap
) {
193 return bdrv_dirty_bitmap_has_successor(bitmap
) ||
194 bdrv_dirty_bitmap_qmp_locked(bitmap
);
197 void bdrv_dirty_bitmap_set_qmp_locked(BdrvDirtyBitmap
*bitmap
, bool qmp_locked
)
199 qemu_mutex_lock(bitmap
->mutex
);
200 bitmap
->qmp_locked
= qmp_locked
;
201 qemu_mutex_unlock(bitmap
->mutex
);
204 bool bdrv_dirty_bitmap_qmp_locked(BdrvDirtyBitmap
*bitmap
)
206 return bitmap
->qmp_locked
;
209 /* Called with BQL taken. */
210 bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap
*bitmap
)
212 return !bitmap
->disabled
;
215 /* Called with BQL taken. */
216 DirtyBitmapStatus
bdrv_dirty_bitmap_status(BdrvDirtyBitmap
*bitmap
)
218 if (bdrv_dirty_bitmap_has_successor(bitmap
)) {
219 return DIRTY_BITMAP_STATUS_FROZEN
;
220 } else if (bdrv_dirty_bitmap_qmp_locked(bitmap
)) {
221 return DIRTY_BITMAP_STATUS_LOCKED
;
222 } else if (!bdrv_dirty_bitmap_enabled(bitmap
)) {
223 return DIRTY_BITMAP_STATUS_DISABLED
;
225 return DIRTY_BITMAP_STATUS_ACTIVE
;
229 /* Called with BQL taken. */
230 static bool bdrv_dirty_bitmap_recording(BdrvDirtyBitmap
*bitmap
)
232 return !bitmap
->disabled
|| (bitmap
->successor
&&
233 !bitmap
->successor
->disabled
);
237 * Create a successor bitmap destined to replace this bitmap after an operation.
238 * Requires that the bitmap is not user_locked and has no successor.
239 * The successor will be enabled if the parent bitmap was.
240 * Called with BQL taken.
242 int bdrv_dirty_bitmap_create_successor(BlockDriverState
*bs
,
243 BdrvDirtyBitmap
*bitmap
, Error
**errp
)
245 uint64_t granularity
;
246 BdrvDirtyBitmap
*child
;
248 if (bdrv_dirty_bitmap_user_locked(bitmap
)) {
249 error_setg(errp
, "Cannot create a successor for a bitmap that is "
250 "in-use by an operation");
253 if (bdrv_dirty_bitmap_has_successor(bitmap
)) {
254 error_setg(errp
, "Cannot create a successor for a bitmap that already "
259 /* Create an anonymous successor */
260 granularity
= bdrv_dirty_bitmap_granularity(bitmap
);
261 child
= bdrv_create_dirty_bitmap(bs
, granularity
, NULL
, errp
);
266 /* Successor will be on or off based on our current state. */
267 child
->disabled
= bitmap
->disabled
;
268 bitmap
->disabled
= true;
270 /* Install the successor and freeze the parent */
271 bitmap
->successor
= child
;
275 void bdrv_enable_dirty_bitmap_locked(BdrvDirtyBitmap
*bitmap
)
277 bitmap
->disabled
= false;
280 /* Called with BQL taken. */
281 void bdrv_dirty_bitmap_enable_successor(BdrvDirtyBitmap
*bitmap
)
283 assert(bitmap
->mutex
== bitmap
->successor
->mutex
);
284 qemu_mutex_lock(bitmap
->mutex
);
285 bdrv_enable_dirty_bitmap_locked(bitmap
->successor
);
286 qemu_mutex_unlock(bitmap
->mutex
);
289 /* Called within bdrv_dirty_bitmap_lock..unlock and with BQL taken. */
290 static void bdrv_release_dirty_bitmap_locked(BdrvDirtyBitmap
*bitmap
)
292 assert(!bitmap
->active_iterators
);
293 assert(!bdrv_dirty_bitmap_user_locked(bitmap
));
294 assert(!bdrv_dirty_bitmap_has_successor(bitmap
));
295 assert(!bitmap
->meta
);
296 QLIST_REMOVE(bitmap
, list
);
297 hbitmap_free(bitmap
->bitmap
);
298 g_free(bitmap
->name
);
303 * For a bitmap with a successor, yield our name to the successor,
304 * delete the old bitmap, and return a handle to the new bitmap.
305 * Called with BQL taken.
307 BdrvDirtyBitmap
*bdrv_dirty_bitmap_abdicate(BlockDriverState
*bs
,
308 BdrvDirtyBitmap
*bitmap
,
312 BdrvDirtyBitmap
*successor
= bitmap
->successor
;
314 if (successor
== NULL
) {
315 error_setg(errp
, "Cannot relinquish control if "
316 "there's no successor present");
322 successor
->name
= name
;
323 bitmap
->successor
= NULL
;
324 successor
->persistent
= bitmap
->persistent
;
325 bitmap
->persistent
= false;
326 bdrv_release_dirty_bitmap(bs
, bitmap
);
332 * In cases of failure where we can no longer safely delete the parent,
333 * we may wish to re-join the parent and child/successor.
334 * The merged parent will not be user_locked.
335 * The marged parent will be enabled if and only if the successor was enabled.
336 * Called within bdrv_dirty_bitmap_lock..unlock and with BQL taken.
338 BdrvDirtyBitmap
*bdrv_reclaim_dirty_bitmap_locked(BlockDriverState
*bs
,
339 BdrvDirtyBitmap
*parent
,
342 BdrvDirtyBitmap
*successor
= parent
->successor
;
345 error_setg(errp
, "Cannot reclaim a successor when none is present");
349 if (!hbitmap_merge(parent
->bitmap
, successor
->bitmap
, parent
->bitmap
)) {
350 error_setg(errp
, "Merging of parent and successor bitmap failed");
354 parent
->disabled
= successor
->disabled
;
355 bdrv_release_dirty_bitmap_locked(successor
);
356 parent
->successor
= NULL
;
361 /* Called with BQL taken. */
362 BdrvDirtyBitmap
*bdrv_reclaim_dirty_bitmap(BlockDriverState
*bs
,
363 BdrvDirtyBitmap
*parent
,
366 BdrvDirtyBitmap
*ret
;
368 qemu_mutex_lock(parent
->mutex
);
369 ret
= bdrv_reclaim_dirty_bitmap_locked(bs
, parent
, errp
);
370 qemu_mutex_unlock(parent
->mutex
);
376 * Truncates _all_ bitmaps attached to a BDS.
377 * Called with BQL taken.
379 void bdrv_dirty_bitmap_truncate(BlockDriverState
*bs
, int64_t bytes
)
381 BdrvDirtyBitmap
*bitmap
;
383 bdrv_dirty_bitmaps_lock(bs
);
384 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
385 assert(!bdrv_dirty_bitmap_user_locked(bitmap
));
386 assert(!bdrv_dirty_bitmap_has_successor(bitmap
));
387 assert(!bitmap
->active_iterators
);
388 hbitmap_truncate(bitmap
->bitmap
, bytes
);
389 bitmap
->size
= bytes
;
391 bdrv_dirty_bitmaps_unlock(bs
);
394 /* Called with BQL taken. */
395 void bdrv_release_dirty_bitmap(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
)
397 bdrv_dirty_bitmaps_lock(bs
);
398 bdrv_release_dirty_bitmap_locked(bitmap
);
399 bdrv_dirty_bitmaps_unlock(bs
);
403 * Release all named dirty bitmaps attached to a BDS (for use in bdrv_close()).
404 * There must not be any user_locked bitmaps attached.
405 * This function does not remove persistent bitmaps from the storage.
406 * Called with BQL taken.
408 void bdrv_release_named_dirty_bitmaps(BlockDriverState
*bs
)
410 BdrvDirtyBitmap
*bm
, *next
;
412 bdrv_dirty_bitmaps_lock(bs
);
413 QLIST_FOREACH_SAFE(bm
, &bs
->dirty_bitmaps
, list
, next
) {
414 if (bdrv_dirty_bitmap_name(bm
)) {
415 bdrv_release_dirty_bitmap_locked(bm
);
418 bdrv_dirty_bitmaps_unlock(bs
);
422 * Remove persistent dirty bitmap from the storage if it exists.
423 * Absence of bitmap is not an error, because we have the following scenario:
424 * BdrvDirtyBitmap can have .persistent = true but not yet saved and have no
425 * stored version. For such bitmap bdrv_remove_persistent_dirty_bitmap() should
427 * This function doesn't release corresponding BdrvDirtyBitmap.
429 void bdrv_remove_persistent_dirty_bitmap(BlockDriverState
*bs
,
433 if (bs
->drv
&& bs
->drv
->bdrv_remove_persistent_dirty_bitmap
) {
434 bs
->drv
->bdrv_remove_persistent_dirty_bitmap(bs
, name
, errp
);
438 void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
440 bdrv_dirty_bitmap_lock(bitmap
);
441 bitmap
->disabled
= true;
442 bdrv_dirty_bitmap_unlock(bitmap
);
445 void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
447 bdrv_dirty_bitmap_lock(bitmap
);
448 bdrv_enable_dirty_bitmap_locked(bitmap
);
449 bdrv_dirty_bitmap_unlock(bitmap
);
452 BlockDirtyInfoList
*bdrv_query_dirty_bitmaps(BlockDriverState
*bs
)
455 BlockDirtyInfoList
*list
= NULL
;
456 BlockDirtyInfoList
**plist
= &list
;
458 bdrv_dirty_bitmaps_lock(bs
);
459 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
460 BlockDirtyInfo
*info
= g_new0(BlockDirtyInfo
, 1);
461 BlockDirtyInfoList
*entry
= g_new0(BlockDirtyInfoList
, 1);
462 info
->count
= bdrv_get_dirty_count(bm
);
463 info
->granularity
= bdrv_dirty_bitmap_granularity(bm
);
464 info
->has_name
= !!bm
->name
;
465 info
->name
= g_strdup(bm
->name
);
466 info
->status
= bdrv_dirty_bitmap_status(bm
);
467 info
->recording
= bdrv_dirty_bitmap_recording(bm
);
468 info
->busy
= bdrv_dirty_bitmap_user_locked(bm
);
469 info
->persistent
= bm
->persistent
;
472 plist
= &entry
->next
;
474 bdrv_dirty_bitmaps_unlock(bs
);
479 /* Called within bdrv_dirty_bitmap_lock..unlock */
480 bool bdrv_get_dirty_locked(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
,
484 return hbitmap_get(bitmap
->bitmap
, offset
);
491 * Chooses a default granularity based on the existing cluster size,
492 * but clamped between [4K, 64K]. Defaults to 64K in the case that there
493 * is no cluster size information available.
495 uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState
*bs
)
498 uint32_t granularity
;
500 if (bdrv_get_info(bs
, &bdi
) >= 0 && bdi
.cluster_size
> 0) {
501 granularity
= MAX(4096, bdi
.cluster_size
);
502 granularity
= MIN(65536, granularity
);
510 uint32_t bdrv_dirty_bitmap_granularity(const BdrvDirtyBitmap
*bitmap
)
512 return 1U << hbitmap_granularity(bitmap
->bitmap
);
515 BdrvDirtyBitmapIter
*bdrv_dirty_iter_new(BdrvDirtyBitmap
*bitmap
)
517 BdrvDirtyBitmapIter
*iter
= g_new(BdrvDirtyBitmapIter
, 1);
518 hbitmap_iter_init(&iter
->hbi
, bitmap
->bitmap
, 0);
519 iter
->bitmap
= bitmap
;
520 bitmap
->active_iterators
++;
524 BdrvDirtyBitmapIter
*bdrv_dirty_meta_iter_new(BdrvDirtyBitmap
*bitmap
)
526 BdrvDirtyBitmapIter
*iter
= g_new(BdrvDirtyBitmapIter
, 1);
527 hbitmap_iter_init(&iter
->hbi
, bitmap
->meta
, 0);
528 iter
->bitmap
= bitmap
;
529 bitmap
->active_iterators
++;
533 void bdrv_dirty_iter_free(BdrvDirtyBitmapIter
*iter
)
538 assert(iter
->bitmap
->active_iterators
> 0);
539 iter
->bitmap
->active_iterators
--;
543 int64_t bdrv_dirty_iter_next(BdrvDirtyBitmapIter
*iter
)
545 return hbitmap_iter_next(&iter
->hbi
);
548 /* Called within bdrv_dirty_bitmap_lock..unlock */
549 void bdrv_set_dirty_bitmap_locked(BdrvDirtyBitmap
*bitmap
,
550 int64_t offset
, int64_t bytes
)
552 assert(!bdrv_dirty_bitmap_readonly(bitmap
));
553 hbitmap_set(bitmap
->bitmap
, offset
, bytes
);
556 void bdrv_set_dirty_bitmap(BdrvDirtyBitmap
*bitmap
,
557 int64_t offset
, int64_t bytes
)
559 bdrv_dirty_bitmap_lock(bitmap
);
560 bdrv_set_dirty_bitmap_locked(bitmap
, offset
, bytes
);
561 bdrv_dirty_bitmap_unlock(bitmap
);
564 /* Called within bdrv_dirty_bitmap_lock..unlock */
565 void bdrv_reset_dirty_bitmap_locked(BdrvDirtyBitmap
*bitmap
,
566 int64_t offset
, int64_t bytes
)
568 assert(!bdrv_dirty_bitmap_readonly(bitmap
));
569 hbitmap_reset(bitmap
->bitmap
, offset
, bytes
);
572 void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap
*bitmap
,
573 int64_t offset
, int64_t bytes
)
575 bdrv_dirty_bitmap_lock(bitmap
);
576 bdrv_reset_dirty_bitmap_locked(bitmap
, offset
, bytes
);
577 bdrv_dirty_bitmap_unlock(bitmap
);
580 void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap
*bitmap
, HBitmap
**out
)
582 assert(!bdrv_dirty_bitmap_readonly(bitmap
));
583 bdrv_dirty_bitmap_lock(bitmap
);
585 hbitmap_reset_all(bitmap
->bitmap
);
587 HBitmap
*backup
= bitmap
->bitmap
;
588 bitmap
->bitmap
= hbitmap_alloc(bitmap
->size
,
589 hbitmap_granularity(backup
));
592 bdrv_dirty_bitmap_unlock(bitmap
);
595 void bdrv_restore_dirty_bitmap(BdrvDirtyBitmap
*bitmap
, HBitmap
*backup
)
597 HBitmap
*tmp
= bitmap
->bitmap
;
598 assert(!bdrv_dirty_bitmap_readonly(bitmap
));
599 bitmap
->bitmap
= backup
;
603 uint64_t bdrv_dirty_bitmap_serialization_size(const BdrvDirtyBitmap
*bitmap
,
604 uint64_t offset
, uint64_t bytes
)
606 return hbitmap_serialization_size(bitmap
->bitmap
, offset
, bytes
);
609 uint64_t bdrv_dirty_bitmap_serialization_align(const BdrvDirtyBitmap
*bitmap
)
611 return hbitmap_serialization_align(bitmap
->bitmap
);
614 void bdrv_dirty_bitmap_serialize_part(const BdrvDirtyBitmap
*bitmap
,
615 uint8_t *buf
, uint64_t offset
,
618 hbitmap_serialize_part(bitmap
->bitmap
, buf
, offset
, bytes
);
621 void bdrv_dirty_bitmap_deserialize_part(BdrvDirtyBitmap
*bitmap
,
622 uint8_t *buf
, uint64_t offset
,
623 uint64_t bytes
, bool finish
)
625 hbitmap_deserialize_part(bitmap
->bitmap
, buf
, offset
, bytes
, finish
);
628 void bdrv_dirty_bitmap_deserialize_zeroes(BdrvDirtyBitmap
*bitmap
,
629 uint64_t offset
, uint64_t bytes
,
632 hbitmap_deserialize_zeroes(bitmap
->bitmap
, offset
, bytes
, finish
);
635 void bdrv_dirty_bitmap_deserialize_ones(BdrvDirtyBitmap
*bitmap
,
636 uint64_t offset
, uint64_t bytes
,
639 hbitmap_deserialize_ones(bitmap
->bitmap
, offset
, bytes
, finish
);
642 void bdrv_dirty_bitmap_deserialize_finish(BdrvDirtyBitmap
*bitmap
)
644 hbitmap_deserialize_finish(bitmap
->bitmap
);
647 void bdrv_set_dirty(BlockDriverState
*bs
, int64_t offset
, int64_t bytes
)
649 BdrvDirtyBitmap
*bitmap
;
651 if (QLIST_EMPTY(&bs
->dirty_bitmaps
)) {
655 bdrv_dirty_bitmaps_lock(bs
);
656 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
657 if (!bdrv_dirty_bitmap_enabled(bitmap
)) {
660 assert(!bdrv_dirty_bitmap_readonly(bitmap
));
661 hbitmap_set(bitmap
->bitmap
, offset
, bytes
);
663 bdrv_dirty_bitmaps_unlock(bs
);
667 * Advance a BdrvDirtyBitmapIter to an arbitrary offset.
669 void bdrv_set_dirty_iter(BdrvDirtyBitmapIter
*iter
, int64_t offset
)
671 hbitmap_iter_init(&iter
->hbi
, iter
->hbi
.hb
, offset
);
674 int64_t bdrv_get_dirty_count(BdrvDirtyBitmap
*bitmap
)
676 return hbitmap_count(bitmap
->bitmap
);
679 int64_t bdrv_get_meta_dirty_count(BdrvDirtyBitmap
*bitmap
)
681 return hbitmap_count(bitmap
->meta
);
684 bool bdrv_dirty_bitmap_readonly(const BdrvDirtyBitmap
*bitmap
)
686 return bitmap
->readonly
;
689 /* Called with BQL taken. */
690 void bdrv_dirty_bitmap_set_readonly(BdrvDirtyBitmap
*bitmap
, bool value
)
692 qemu_mutex_lock(bitmap
->mutex
);
693 bitmap
->readonly
= value
;
694 qemu_mutex_unlock(bitmap
->mutex
);
697 bool bdrv_has_readonly_bitmaps(BlockDriverState
*bs
)
700 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
709 /* Called with BQL taken. */
710 void bdrv_dirty_bitmap_set_persistance(BdrvDirtyBitmap
*bitmap
, bool persistent
)
712 qemu_mutex_lock(bitmap
->mutex
);
713 bitmap
->persistent
= persistent
;
714 qemu_mutex_unlock(bitmap
->mutex
);
717 /* Called with BQL taken. */
718 void bdrv_dirty_bitmap_set_migration(BdrvDirtyBitmap
*bitmap
, bool migration
)
720 qemu_mutex_lock(bitmap
->mutex
);
721 bitmap
->migration
= migration
;
722 qemu_mutex_unlock(bitmap
->mutex
);
725 bool bdrv_dirty_bitmap_get_persistance(BdrvDirtyBitmap
*bitmap
)
727 return bitmap
->persistent
&& !bitmap
->migration
;
730 bool bdrv_has_changed_persistent_bitmaps(BlockDriverState
*bs
)
733 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
734 if (bm
->persistent
&& !bm
->readonly
&& !bm
->migration
) {
742 BdrvDirtyBitmap
*bdrv_dirty_bitmap_next(BlockDriverState
*bs
,
743 BdrvDirtyBitmap
*bitmap
)
745 return bitmap
== NULL
? QLIST_FIRST(&bs
->dirty_bitmaps
) :
746 QLIST_NEXT(bitmap
, list
);
749 char *bdrv_dirty_bitmap_sha256(const BdrvDirtyBitmap
*bitmap
, Error
**errp
)
751 return hbitmap_sha256(bitmap
->bitmap
, errp
);
754 int64_t bdrv_dirty_bitmap_next_zero(BdrvDirtyBitmap
*bitmap
, uint64_t offset
,
757 return hbitmap_next_zero(bitmap
->bitmap
, offset
, bytes
);
760 bool bdrv_dirty_bitmap_next_dirty_area(BdrvDirtyBitmap
*bitmap
,
761 uint64_t *offset
, uint64_t *bytes
)
763 return hbitmap_next_dirty_area(bitmap
->bitmap
, offset
, bytes
);
766 void bdrv_merge_dirty_bitmap(BdrvDirtyBitmap
*dest
, const BdrvDirtyBitmap
*src
,
767 HBitmap
**backup
, Error
**errp
)
771 /* only bitmaps from one bds are supported */
772 assert(dest
->mutex
== src
->mutex
);
774 qemu_mutex_lock(dest
->mutex
);
776 if (bdrv_dirty_bitmap_user_locked(dest
)) {
777 error_setg(errp
, "Bitmap '%s' is currently in use by another"
778 " operation and cannot be modified", dest
->name
);
782 if (bdrv_dirty_bitmap_readonly(dest
)) {
783 error_setg(errp
, "Bitmap '%s' is readonly and cannot be modified",
788 if (!hbitmap_can_merge(dest
->bitmap
, src
->bitmap
)) {
789 error_setg(errp
, "Bitmaps are incompatible and can't be merged");
794 *backup
= dest
->bitmap
;
795 dest
->bitmap
= hbitmap_alloc(dest
->size
, hbitmap_granularity(*backup
));
796 ret
= hbitmap_merge(*backup
, src
->bitmap
, dest
->bitmap
);
798 ret
= hbitmap_merge(dest
->bitmap
, src
->bitmap
, dest
->bitmap
);
803 qemu_mutex_unlock(dest
->mutex
);