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
|| bitmap
->successor
);
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 * Called with BQL taken.
241 int bdrv_dirty_bitmap_create_successor(BlockDriverState
*bs
,
242 BdrvDirtyBitmap
*bitmap
, Error
**errp
)
244 uint64_t granularity
;
245 BdrvDirtyBitmap
*child
;
247 if (bdrv_dirty_bitmap_user_locked(bitmap
)) {
248 error_setg(errp
, "Cannot create a successor for a bitmap that is "
249 "in-use by an operation");
252 if (bdrv_dirty_bitmap_has_successor(bitmap
)) {
253 error_setg(errp
, "Cannot create a successor for a bitmap that already "
258 /* Create an anonymous successor */
259 granularity
= bdrv_dirty_bitmap_granularity(bitmap
);
260 child
= bdrv_create_dirty_bitmap(bs
, granularity
, NULL
, errp
);
265 /* Successor will be on or off based on our current state. */
266 child
->disabled
= bitmap
->disabled
;
268 /* Install the successor and freeze the parent */
269 bitmap
->successor
= child
;
273 void bdrv_enable_dirty_bitmap_locked(BdrvDirtyBitmap
*bitmap
)
275 bitmap
->disabled
= false;
278 /* Called with BQL taken. */
279 void bdrv_dirty_bitmap_enable_successor(BdrvDirtyBitmap
*bitmap
)
281 assert(bitmap
->mutex
== bitmap
->successor
->mutex
);
282 qemu_mutex_lock(bitmap
->mutex
);
283 bdrv_enable_dirty_bitmap_locked(bitmap
->successor
);
284 qemu_mutex_unlock(bitmap
->mutex
);
287 /* Called within bdrv_dirty_bitmap_lock..unlock and with BQL taken. */
288 static void bdrv_release_dirty_bitmap_locked(BdrvDirtyBitmap
*bitmap
)
290 assert(!bitmap
->active_iterators
);
291 assert(!bdrv_dirty_bitmap_user_locked(bitmap
));
292 assert(!bdrv_dirty_bitmap_has_successor(bitmap
));
293 assert(!bitmap
->meta
);
294 QLIST_REMOVE(bitmap
, list
);
295 hbitmap_free(bitmap
->bitmap
);
296 g_free(bitmap
->name
);
301 * For a bitmap with a successor, yield our name to the successor,
302 * delete the old bitmap, and return a handle to the new bitmap.
303 * Called with BQL taken.
305 BdrvDirtyBitmap
*bdrv_dirty_bitmap_abdicate(BlockDriverState
*bs
,
306 BdrvDirtyBitmap
*bitmap
,
310 BdrvDirtyBitmap
*successor
= bitmap
->successor
;
312 if (successor
== NULL
) {
313 error_setg(errp
, "Cannot relinquish control if "
314 "there's no successor present");
320 successor
->name
= name
;
321 bitmap
->successor
= NULL
;
322 successor
->persistent
= bitmap
->persistent
;
323 bitmap
->persistent
= false;
324 bdrv_release_dirty_bitmap(bs
, bitmap
);
330 * In cases of failure where we can no longer safely delete the parent,
331 * we may wish to re-join the parent and child/successor.
332 * The merged parent will not be user_locked, nor explicitly re-enabled.
333 * Called within bdrv_dirty_bitmap_lock..unlock and with BQL taken.
335 BdrvDirtyBitmap
*bdrv_reclaim_dirty_bitmap_locked(BlockDriverState
*bs
,
336 BdrvDirtyBitmap
*parent
,
339 BdrvDirtyBitmap
*successor
= parent
->successor
;
342 error_setg(errp
, "Cannot reclaim a successor when none is present");
346 if (!hbitmap_merge(parent
->bitmap
, successor
->bitmap
, parent
->bitmap
)) {
347 error_setg(errp
, "Merging of parent and successor bitmap failed");
350 bdrv_release_dirty_bitmap_locked(successor
);
351 parent
->successor
= NULL
;
356 /* Called with BQL taken. */
357 BdrvDirtyBitmap
*bdrv_reclaim_dirty_bitmap(BlockDriverState
*bs
,
358 BdrvDirtyBitmap
*parent
,
361 BdrvDirtyBitmap
*ret
;
363 qemu_mutex_lock(parent
->mutex
);
364 ret
= bdrv_reclaim_dirty_bitmap_locked(bs
, parent
, errp
);
365 qemu_mutex_unlock(parent
->mutex
);
371 * Truncates _all_ bitmaps attached to a BDS.
372 * Called with BQL taken.
374 void bdrv_dirty_bitmap_truncate(BlockDriverState
*bs
, int64_t bytes
)
376 BdrvDirtyBitmap
*bitmap
;
378 bdrv_dirty_bitmaps_lock(bs
);
379 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
380 assert(!bdrv_dirty_bitmap_user_locked(bitmap
));
381 assert(!bdrv_dirty_bitmap_has_successor(bitmap
));
382 assert(!bitmap
->active_iterators
);
383 hbitmap_truncate(bitmap
->bitmap
, bytes
);
384 bitmap
->size
= bytes
;
386 bdrv_dirty_bitmaps_unlock(bs
);
389 /* Called with BQL taken. */
390 void bdrv_release_dirty_bitmap(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
)
392 bdrv_dirty_bitmaps_lock(bs
);
393 bdrv_release_dirty_bitmap_locked(bitmap
);
394 bdrv_dirty_bitmaps_unlock(bs
);
398 * Release all named dirty bitmaps attached to a BDS (for use in bdrv_close()).
399 * There must not be any user_locked bitmaps attached.
400 * This function does not remove persistent bitmaps from the storage.
401 * Called with BQL taken.
403 void bdrv_release_named_dirty_bitmaps(BlockDriverState
*bs
)
405 BdrvDirtyBitmap
*bm
, *next
;
407 bdrv_dirty_bitmaps_lock(bs
);
408 QLIST_FOREACH_SAFE(bm
, &bs
->dirty_bitmaps
, list
, next
) {
409 if (bdrv_dirty_bitmap_name(bm
)) {
410 bdrv_release_dirty_bitmap_locked(bm
);
413 bdrv_dirty_bitmaps_unlock(bs
);
417 * Remove persistent dirty bitmap from the storage if it exists.
418 * Absence of bitmap is not an error, because we have the following scenario:
419 * BdrvDirtyBitmap can have .persistent = true but not yet saved and have no
420 * stored version. For such bitmap bdrv_remove_persistent_dirty_bitmap() should
422 * This function doesn't release corresponding BdrvDirtyBitmap.
424 void bdrv_remove_persistent_dirty_bitmap(BlockDriverState
*bs
,
428 if (bs
->drv
&& bs
->drv
->bdrv_remove_persistent_dirty_bitmap
) {
429 bs
->drv
->bdrv_remove_persistent_dirty_bitmap(bs
, name
, errp
);
433 void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
435 bdrv_dirty_bitmap_lock(bitmap
);
436 bitmap
->disabled
= true;
437 bdrv_dirty_bitmap_unlock(bitmap
);
440 void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
442 bdrv_dirty_bitmap_lock(bitmap
);
443 bdrv_enable_dirty_bitmap_locked(bitmap
);
444 bdrv_dirty_bitmap_unlock(bitmap
);
447 BlockDirtyInfoList
*bdrv_query_dirty_bitmaps(BlockDriverState
*bs
)
450 BlockDirtyInfoList
*list
= NULL
;
451 BlockDirtyInfoList
**plist
= &list
;
453 bdrv_dirty_bitmaps_lock(bs
);
454 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
455 BlockDirtyInfo
*info
= g_new0(BlockDirtyInfo
, 1);
456 BlockDirtyInfoList
*entry
= g_new0(BlockDirtyInfoList
, 1);
457 info
->count
= bdrv_get_dirty_count(bm
);
458 info
->granularity
= bdrv_dirty_bitmap_granularity(bm
);
459 info
->has_name
= !!bm
->name
;
460 info
->name
= g_strdup(bm
->name
);
461 info
->status
= bdrv_dirty_bitmap_status(bm
);
462 info
->recording
= bdrv_dirty_bitmap_recording(bm
);
463 info
->busy
= bdrv_dirty_bitmap_user_locked(bm
);
464 info
->persistent
= bm
->persistent
;
467 plist
= &entry
->next
;
469 bdrv_dirty_bitmaps_unlock(bs
);
474 /* Called within bdrv_dirty_bitmap_lock..unlock */
475 bool bdrv_get_dirty_locked(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
,
479 return hbitmap_get(bitmap
->bitmap
, offset
);
486 * Chooses a default granularity based on the existing cluster size,
487 * but clamped between [4K, 64K]. Defaults to 64K in the case that there
488 * is no cluster size information available.
490 uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState
*bs
)
493 uint32_t granularity
;
495 if (bdrv_get_info(bs
, &bdi
) >= 0 && bdi
.cluster_size
> 0) {
496 granularity
= MAX(4096, bdi
.cluster_size
);
497 granularity
= MIN(65536, granularity
);
505 uint32_t bdrv_dirty_bitmap_granularity(const BdrvDirtyBitmap
*bitmap
)
507 return 1U << hbitmap_granularity(bitmap
->bitmap
);
510 BdrvDirtyBitmapIter
*bdrv_dirty_iter_new(BdrvDirtyBitmap
*bitmap
)
512 BdrvDirtyBitmapIter
*iter
= g_new(BdrvDirtyBitmapIter
, 1);
513 hbitmap_iter_init(&iter
->hbi
, bitmap
->bitmap
, 0);
514 iter
->bitmap
= bitmap
;
515 bitmap
->active_iterators
++;
519 BdrvDirtyBitmapIter
*bdrv_dirty_meta_iter_new(BdrvDirtyBitmap
*bitmap
)
521 BdrvDirtyBitmapIter
*iter
= g_new(BdrvDirtyBitmapIter
, 1);
522 hbitmap_iter_init(&iter
->hbi
, bitmap
->meta
, 0);
523 iter
->bitmap
= bitmap
;
524 bitmap
->active_iterators
++;
528 void bdrv_dirty_iter_free(BdrvDirtyBitmapIter
*iter
)
533 assert(iter
->bitmap
->active_iterators
> 0);
534 iter
->bitmap
->active_iterators
--;
538 int64_t bdrv_dirty_iter_next(BdrvDirtyBitmapIter
*iter
)
540 return hbitmap_iter_next(&iter
->hbi
);
543 /* Called within bdrv_dirty_bitmap_lock..unlock */
544 void bdrv_set_dirty_bitmap_locked(BdrvDirtyBitmap
*bitmap
,
545 int64_t offset
, int64_t bytes
)
547 assert(bdrv_dirty_bitmap_enabled(bitmap
));
548 assert(!bdrv_dirty_bitmap_readonly(bitmap
));
549 hbitmap_set(bitmap
->bitmap
, offset
, bytes
);
552 void bdrv_set_dirty_bitmap(BdrvDirtyBitmap
*bitmap
,
553 int64_t offset
, int64_t bytes
)
555 bdrv_dirty_bitmap_lock(bitmap
);
556 bdrv_set_dirty_bitmap_locked(bitmap
, offset
, bytes
);
557 bdrv_dirty_bitmap_unlock(bitmap
);
560 /* Called within bdrv_dirty_bitmap_lock..unlock */
561 void bdrv_reset_dirty_bitmap_locked(BdrvDirtyBitmap
*bitmap
,
562 int64_t offset
, int64_t bytes
)
564 assert(bdrv_dirty_bitmap_enabled(bitmap
));
565 assert(!bdrv_dirty_bitmap_readonly(bitmap
));
566 hbitmap_reset(bitmap
->bitmap
, offset
, bytes
);
569 void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap
*bitmap
,
570 int64_t offset
, int64_t bytes
)
572 bdrv_dirty_bitmap_lock(bitmap
);
573 bdrv_reset_dirty_bitmap_locked(bitmap
, offset
, bytes
);
574 bdrv_dirty_bitmap_unlock(bitmap
);
577 void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap
*bitmap
, HBitmap
**out
)
579 assert(!bdrv_dirty_bitmap_readonly(bitmap
));
580 bdrv_dirty_bitmap_lock(bitmap
);
582 hbitmap_reset_all(bitmap
->bitmap
);
584 HBitmap
*backup
= bitmap
->bitmap
;
585 bitmap
->bitmap
= hbitmap_alloc(bitmap
->size
,
586 hbitmap_granularity(backup
));
589 bdrv_dirty_bitmap_unlock(bitmap
);
592 void bdrv_restore_dirty_bitmap(BdrvDirtyBitmap
*bitmap
, HBitmap
*backup
)
594 HBitmap
*tmp
= bitmap
->bitmap
;
595 assert(!bdrv_dirty_bitmap_readonly(bitmap
));
596 bitmap
->bitmap
= backup
;
600 uint64_t bdrv_dirty_bitmap_serialization_size(const BdrvDirtyBitmap
*bitmap
,
601 uint64_t offset
, uint64_t bytes
)
603 return hbitmap_serialization_size(bitmap
->bitmap
, offset
, bytes
);
606 uint64_t bdrv_dirty_bitmap_serialization_align(const BdrvDirtyBitmap
*bitmap
)
608 return hbitmap_serialization_align(bitmap
->bitmap
);
611 void bdrv_dirty_bitmap_serialize_part(const BdrvDirtyBitmap
*bitmap
,
612 uint8_t *buf
, uint64_t offset
,
615 hbitmap_serialize_part(bitmap
->bitmap
, buf
, offset
, bytes
);
618 void bdrv_dirty_bitmap_deserialize_part(BdrvDirtyBitmap
*bitmap
,
619 uint8_t *buf
, uint64_t offset
,
620 uint64_t bytes
, bool finish
)
622 hbitmap_deserialize_part(bitmap
->bitmap
, buf
, offset
, bytes
, finish
);
625 void bdrv_dirty_bitmap_deserialize_zeroes(BdrvDirtyBitmap
*bitmap
,
626 uint64_t offset
, uint64_t bytes
,
629 hbitmap_deserialize_zeroes(bitmap
->bitmap
, offset
, bytes
, finish
);
632 void bdrv_dirty_bitmap_deserialize_ones(BdrvDirtyBitmap
*bitmap
,
633 uint64_t offset
, uint64_t bytes
,
636 hbitmap_deserialize_ones(bitmap
->bitmap
, offset
, bytes
, finish
);
639 void bdrv_dirty_bitmap_deserialize_finish(BdrvDirtyBitmap
*bitmap
)
641 hbitmap_deserialize_finish(bitmap
->bitmap
);
644 void bdrv_set_dirty(BlockDriverState
*bs
, int64_t offset
, int64_t bytes
)
646 BdrvDirtyBitmap
*bitmap
;
648 if (QLIST_EMPTY(&bs
->dirty_bitmaps
)) {
652 bdrv_dirty_bitmaps_lock(bs
);
653 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
654 if (!bdrv_dirty_bitmap_enabled(bitmap
)) {
657 assert(!bdrv_dirty_bitmap_readonly(bitmap
));
658 hbitmap_set(bitmap
->bitmap
, offset
, bytes
);
660 bdrv_dirty_bitmaps_unlock(bs
);
664 * Advance a BdrvDirtyBitmapIter to an arbitrary offset.
666 void bdrv_set_dirty_iter(BdrvDirtyBitmapIter
*iter
, int64_t offset
)
668 hbitmap_iter_init(&iter
->hbi
, iter
->hbi
.hb
, offset
);
671 int64_t bdrv_get_dirty_count(BdrvDirtyBitmap
*bitmap
)
673 return hbitmap_count(bitmap
->bitmap
);
676 int64_t bdrv_get_meta_dirty_count(BdrvDirtyBitmap
*bitmap
)
678 return hbitmap_count(bitmap
->meta
);
681 bool bdrv_dirty_bitmap_readonly(const BdrvDirtyBitmap
*bitmap
)
683 return bitmap
->readonly
;
686 /* Called with BQL taken. */
687 void bdrv_dirty_bitmap_set_readonly(BdrvDirtyBitmap
*bitmap
, bool value
)
689 qemu_mutex_lock(bitmap
->mutex
);
690 bitmap
->readonly
= value
;
691 qemu_mutex_unlock(bitmap
->mutex
);
694 bool bdrv_has_readonly_bitmaps(BlockDriverState
*bs
)
697 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
706 /* Called with BQL taken. */
707 void bdrv_dirty_bitmap_set_persistance(BdrvDirtyBitmap
*bitmap
, bool persistent
)
709 qemu_mutex_lock(bitmap
->mutex
);
710 bitmap
->persistent
= persistent
;
711 qemu_mutex_unlock(bitmap
->mutex
);
714 /* Called with BQL taken. */
715 void bdrv_dirty_bitmap_set_migration(BdrvDirtyBitmap
*bitmap
, bool migration
)
717 qemu_mutex_lock(bitmap
->mutex
);
718 bitmap
->migration
= migration
;
719 qemu_mutex_unlock(bitmap
->mutex
);
722 bool bdrv_dirty_bitmap_get_persistance(BdrvDirtyBitmap
*bitmap
)
724 return bitmap
->persistent
&& !bitmap
->migration
;
727 bool bdrv_has_changed_persistent_bitmaps(BlockDriverState
*bs
)
730 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
731 if (bm
->persistent
&& !bm
->readonly
&& !bm
->migration
) {
739 BdrvDirtyBitmap
*bdrv_dirty_bitmap_next(BlockDriverState
*bs
,
740 BdrvDirtyBitmap
*bitmap
)
742 return bitmap
== NULL
? QLIST_FIRST(&bs
->dirty_bitmaps
) :
743 QLIST_NEXT(bitmap
, list
);
746 char *bdrv_dirty_bitmap_sha256(const BdrvDirtyBitmap
*bitmap
, Error
**errp
)
748 return hbitmap_sha256(bitmap
->bitmap
, errp
);
751 int64_t bdrv_dirty_bitmap_next_zero(BdrvDirtyBitmap
*bitmap
, uint64_t offset
,
754 return hbitmap_next_zero(bitmap
->bitmap
, offset
, bytes
);
757 bool bdrv_dirty_bitmap_next_dirty_area(BdrvDirtyBitmap
*bitmap
,
758 uint64_t *offset
, uint64_t *bytes
)
760 return hbitmap_next_dirty_area(bitmap
->bitmap
, offset
, bytes
);
763 void bdrv_merge_dirty_bitmap(BdrvDirtyBitmap
*dest
, const BdrvDirtyBitmap
*src
,
764 HBitmap
**backup
, Error
**errp
)
768 /* only bitmaps from one bds are supported */
769 assert(dest
->mutex
== src
->mutex
);
771 qemu_mutex_lock(dest
->mutex
);
773 if (bdrv_dirty_bitmap_user_locked(dest
)) {
774 error_setg(errp
, "Bitmap '%s' is currently in use by another"
775 " operation and cannot be modified", dest
->name
);
779 if (bdrv_dirty_bitmap_readonly(dest
)) {
780 error_setg(errp
, "Bitmap '%s' is readonly and cannot be modified",
785 if (!hbitmap_can_merge(dest
->bitmap
, src
->bitmap
)) {
786 error_setg(errp
, "Bitmaps are incompatible and can't be merged");
791 *backup
= dest
->bitmap
;
792 dest
->bitmap
= hbitmap_alloc(dest
->size
, hbitmap_granularity(*backup
));
793 ret
= hbitmap_merge(*backup
, src
->bitmap
, dest
->bitmap
);
795 ret
= hbitmap_merge(dest
->bitmap
, src
->bitmap
, dest
->bitmap
);
800 qemu_mutex_unlock(dest
->mutex
);