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"
27 #include "block/block_int.h"
28 #include "block/blockjob.h"
29 #include "qemu/main-loop.h"
31 struct BdrvDirtyBitmap
{
33 HBitmap
*bitmap
; /* Dirty bitmap implementation */
34 bool busy
; /* Bitmap is busy, it can't be used via QMP */
35 BdrvDirtyBitmap
*successor
; /* Anonymous child, if any. */
36 char *name
; /* Optional non-empty unique ID */
37 int64_t size
; /* Size of the bitmap, in bytes */
38 bool disabled
; /* Bitmap is disabled. It ignores all writes to
40 int active_iterators
; /* How many iterators are active */
41 bool readonly
; /* Bitmap is read-only. This field also
42 prevents the respective image from being
43 modified (i.e. blocks writes and discards).
44 Such operations must fail and both the image
45 and this bitmap must remain unchanged while
47 bool persistent
; /* bitmap must be saved to owner disk image */
48 bool inconsistent
; /* bitmap is persistent, but inconsistent.
49 It cannot be used at all in any way, except
50 a QMP user can remove it. */
51 bool skip_store
; /* We are either migrating or deleting this
52 * bitmap; it should not be stored on the next
54 QLIST_ENTRY(BdrvDirtyBitmap
) list
;
57 struct BdrvDirtyBitmapIter
{
59 BdrvDirtyBitmap
*bitmap
;
62 static inline void bdrv_dirty_bitmaps_lock(BlockDriverState
*bs
)
64 qemu_mutex_lock(&bs
->dirty_bitmap_mutex
);
67 static inline void bdrv_dirty_bitmaps_unlock(BlockDriverState
*bs
)
69 qemu_mutex_unlock(&bs
->dirty_bitmap_mutex
);
72 void bdrv_dirty_bitmap_lock(BdrvDirtyBitmap
*bitmap
)
74 bdrv_dirty_bitmaps_lock(bitmap
->bs
);
77 void bdrv_dirty_bitmap_unlock(BdrvDirtyBitmap
*bitmap
)
79 bdrv_dirty_bitmaps_unlock(bitmap
->bs
);
82 /* Called with BQL or dirty_bitmap lock taken. */
83 BdrvDirtyBitmap
*bdrv_find_dirty_bitmap(BlockDriverState
*bs
, const char *name
)
88 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
89 if (bm
->name
&& !strcmp(name
, bm
->name
)) {
96 /* Called with BQL taken. */
97 BdrvDirtyBitmap
*bdrv_create_dirty_bitmap(BlockDriverState
*bs
,
103 BdrvDirtyBitmap
*bitmap
;
105 assert(is_power_of_2(granularity
) && granularity
>= BDRV_SECTOR_SIZE
);
108 if (bdrv_find_dirty_bitmap(bs
, name
)) {
109 error_setg(errp
, "Bitmap already exists: %s", name
);
112 if (strlen(name
) > BDRV_BITMAP_MAX_NAME_SIZE
) {
113 error_setg(errp
, "Bitmap name too long: %s", name
);
117 bitmap_size
= bdrv_getlength(bs
);
118 if (bitmap_size
< 0) {
119 error_setg_errno(errp
, -bitmap_size
, "could not get length of device");
120 errno
= -bitmap_size
;
123 bitmap
= g_new0(BdrvDirtyBitmap
, 1);
125 bitmap
->bitmap
= hbitmap_alloc(bitmap_size
, ctz32(granularity
));
126 bitmap
->size
= bitmap_size
;
127 bitmap
->name
= g_strdup(name
);
128 bitmap
->disabled
= false;
129 bdrv_dirty_bitmaps_lock(bs
);
130 QLIST_INSERT_HEAD(&bs
->dirty_bitmaps
, bitmap
, list
);
131 bdrv_dirty_bitmaps_unlock(bs
);
135 int64_t bdrv_dirty_bitmap_size(const BdrvDirtyBitmap
*bitmap
)
140 const char *bdrv_dirty_bitmap_name(const BdrvDirtyBitmap
*bitmap
)
145 /* Called with BQL taken. */
146 bool bdrv_dirty_bitmap_has_successor(BdrvDirtyBitmap
*bitmap
)
148 return bitmap
->successor
;
151 static bool bdrv_dirty_bitmap_busy(const BdrvDirtyBitmap
*bitmap
)
156 void bdrv_dirty_bitmap_set_busy(BdrvDirtyBitmap
*bitmap
, bool busy
)
158 bdrv_dirty_bitmaps_lock(bitmap
->bs
);
160 bdrv_dirty_bitmaps_unlock(bitmap
->bs
);
163 /* Called with BQL taken. */
164 bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap
*bitmap
)
166 return !bitmap
->disabled
;
169 /* Called with BQL taken. */
170 static bool bdrv_dirty_bitmap_recording(BdrvDirtyBitmap
*bitmap
)
172 return !bitmap
->disabled
|| (bitmap
->successor
&&
173 !bitmap
->successor
->disabled
);
176 int bdrv_dirty_bitmap_check(const BdrvDirtyBitmap
*bitmap
, uint32_t flags
,
179 if ((flags
& BDRV_BITMAP_BUSY
) && bdrv_dirty_bitmap_busy(bitmap
)) {
180 error_setg(errp
, "Bitmap '%s' is currently in use by another"
181 " operation and cannot be used", bitmap
->name
);
185 if ((flags
& BDRV_BITMAP_RO
) && bdrv_dirty_bitmap_readonly(bitmap
)) {
186 error_setg(errp
, "Bitmap '%s' is readonly and cannot be modified",
191 if ((flags
& BDRV_BITMAP_INCONSISTENT
) &&
192 bdrv_dirty_bitmap_inconsistent(bitmap
)) {
193 error_setg(errp
, "Bitmap '%s' is inconsistent and cannot be used",
195 error_append_hint(errp
, "Try block-dirty-bitmap-remove to delete"
196 " this bitmap from disk\n");
204 * Create a successor bitmap destined to replace this bitmap after an operation.
205 * Requires that the bitmap is not marked busy and has no successor.
206 * The successor will be enabled if the parent bitmap was.
207 * Called with BQL taken.
209 int bdrv_dirty_bitmap_create_successor(BdrvDirtyBitmap
*bitmap
, Error
**errp
)
211 uint64_t granularity
;
212 BdrvDirtyBitmap
*child
;
214 if (bdrv_dirty_bitmap_check(bitmap
, BDRV_BITMAP_BUSY
, errp
)) {
217 if (bdrv_dirty_bitmap_has_successor(bitmap
)) {
218 error_setg(errp
, "Cannot create a successor for a bitmap that already "
223 /* Create an anonymous successor */
224 granularity
= bdrv_dirty_bitmap_granularity(bitmap
);
225 child
= bdrv_create_dirty_bitmap(bitmap
->bs
, granularity
, NULL
, errp
);
230 /* Successor will be on or off based on our current state. */
231 child
->disabled
= bitmap
->disabled
;
232 bitmap
->disabled
= true;
234 /* Install the successor and mark the parent as busy */
235 bitmap
->successor
= child
;
240 void bdrv_enable_dirty_bitmap_locked(BdrvDirtyBitmap
*bitmap
)
242 bitmap
->disabled
= false;
245 /* Called with BQL taken. */
246 void bdrv_dirty_bitmap_enable_successor(BdrvDirtyBitmap
*bitmap
)
248 assert(bitmap
->bs
== bitmap
->successor
->bs
);
249 bdrv_dirty_bitmaps_lock(bitmap
->bs
);
250 bdrv_enable_dirty_bitmap_locked(bitmap
->successor
);
251 bdrv_dirty_bitmaps_unlock(bitmap
->bs
);
254 /* Called within bdrv_dirty_bitmap_lock..unlock and with BQL taken. */
255 static void bdrv_release_dirty_bitmap_locked(BdrvDirtyBitmap
*bitmap
)
257 assert(!bitmap
->active_iterators
);
258 assert(!bdrv_dirty_bitmap_busy(bitmap
));
259 assert(!bdrv_dirty_bitmap_has_successor(bitmap
));
260 QLIST_REMOVE(bitmap
, list
);
261 hbitmap_free(bitmap
->bitmap
);
262 g_free(bitmap
->name
);
267 * For a bitmap with a successor, yield our name to the successor,
268 * delete the old bitmap, and return a handle to the new bitmap.
269 * Called with BQL taken.
271 BdrvDirtyBitmap
*bdrv_dirty_bitmap_abdicate(BdrvDirtyBitmap
*bitmap
,
275 BdrvDirtyBitmap
*successor
= bitmap
->successor
;
277 if (successor
== NULL
) {
278 error_setg(errp
, "Cannot relinquish control if "
279 "there's no successor present");
285 successor
->name
= name
;
286 bitmap
->successor
= NULL
;
287 successor
->persistent
= bitmap
->persistent
;
288 bitmap
->persistent
= false;
289 bitmap
->busy
= false;
290 bdrv_release_dirty_bitmap(bitmap
);
296 * In cases of failure where we can no longer safely delete the parent,
297 * we may wish to re-join the parent and child/successor.
298 * The merged parent will be marked as not busy.
299 * The marged parent will be enabled if and only if the successor was enabled.
300 * Called within bdrv_dirty_bitmap_lock..unlock and with BQL taken.
302 BdrvDirtyBitmap
*bdrv_reclaim_dirty_bitmap_locked(BdrvDirtyBitmap
*parent
,
305 BdrvDirtyBitmap
*successor
= parent
->successor
;
308 error_setg(errp
, "Cannot reclaim a successor when none is present");
312 if (!hbitmap_merge(parent
->bitmap
, successor
->bitmap
, parent
->bitmap
)) {
313 error_setg(errp
, "Merging of parent and successor bitmap failed");
317 parent
->disabled
= successor
->disabled
;
318 parent
->busy
= false;
319 bdrv_release_dirty_bitmap_locked(successor
);
320 parent
->successor
= NULL
;
325 /* Called with BQL taken. */
326 BdrvDirtyBitmap
*bdrv_reclaim_dirty_bitmap(BdrvDirtyBitmap
*parent
,
329 BdrvDirtyBitmap
*ret
;
331 bdrv_dirty_bitmaps_lock(parent
->bs
);
332 ret
= bdrv_reclaim_dirty_bitmap_locked(parent
, errp
);
333 bdrv_dirty_bitmaps_unlock(parent
->bs
);
339 * Truncates _all_ bitmaps attached to a BDS.
340 * Called with BQL taken.
342 void bdrv_dirty_bitmap_truncate(BlockDriverState
*bs
, int64_t bytes
)
344 BdrvDirtyBitmap
*bitmap
;
346 bdrv_dirty_bitmaps_lock(bs
);
347 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
348 assert(!bdrv_dirty_bitmap_busy(bitmap
));
349 assert(!bdrv_dirty_bitmap_has_successor(bitmap
));
350 assert(!bitmap
->active_iterators
);
351 hbitmap_truncate(bitmap
->bitmap
, bytes
);
352 bitmap
->size
= bytes
;
354 bdrv_dirty_bitmaps_unlock(bs
);
357 /* Called with BQL taken. */
358 void bdrv_release_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
360 BlockDriverState
*bs
= bitmap
->bs
;
362 bdrv_dirty_bitmaps_lock(bs
);
363 bdrv_release_dirty_bitmap_locked(bitmap
);
364 bdrv_dirty_bitmaps_unlock(bs
);
368 * Release all named dirty bitmaps attached to a BDS (for use in bdrv_close()).
369 * There must not be any busy bitmaps attached.
370 * This function does not remove persistent bitmaps from the storage.
371 * Called with BQL taken.
373 void bdrv_release_named_dirty_bitmaps(BlockDriverState
*bs
)
375 BdrvDirtyBitmap
*bm
, *next
;
377 bdrv_dirty_bitmaps_lock(bs
);
378 QLIST_FOREACH_SAFE(bm
, &bs
->dirty_bitmaps
, list
, next
) {
379 if (bdrv_dirty_bitmap_name(bm
)) {
380 bdrv_release_dirty_bitmap_locked(bm
);
383 bdrv_dirty_bitmaps_unlock(bs
);
387 * Remove persistent dirty bitmap from the storage if it exists.
388 * Absence of bitmap is not an error, because we have the following scenario:
389 * BdrvDirtyBitmap can have .persistent = true but not yet saved and have no
390 * stored version. For such bitmap bdrv_remove_persistent_dirty_bitmap() should
392 * This function doesn't release corresponding BdrvDirtyBitmap.
394 static int coroutine_fn
395 bdrv_co_remove_persistent_dirty_bitmap(BlockDriverState
*bs
, const char *name
,
398 if (bs
->drv
&& bs
->drv
->bdrv_co_remove_persistent_dirty_bitmap
) {
399 return bs
->drv
->bdrv_co_remove_persistent_dirty_bitmap(bs
, name
, errp
);
405 typedef struct BdrvRemovePersistentDirtyBitmapCo
{
406 BlockDriverState
*bs
;
410 } BdrvRemovePersistentDirtyBitmapCo
;
412 static void coroutine_fn
413 bdrv_co_remove_persistent_dirty_bitmap_entry(void *opaque
)
415 BdrvRemovePersistentDirtyBitmapCo
*s
= opaque
;
417 s
->ret
= bdrv_co_remove_persistent_dirty_bitmap(s
->bs
, s
->name
, s
->errp
);
421 int bdrv_remove_persistent_dirty_bitmap(BlockDriverState
*bs
, const char *name
,
424 if (qemu_in_coroutine()) {
425 return bdrv_co_remove_persistent_dirty_bitmap(bs
, name
, errp
);
428 BdrvRemovePersistentDirtyBitmapCo s
= {
435 co
= qemu_coroutine_create(bdrv_co_remove_persistent_dirty_bitmap_entry
,
437 bdrv_coroutine_enter(bs
, co
);
438 BDRV_POLL_WHILE(bs
, s
.ret
== -EINPROGRESS
);
445 bdrv_supports_persistent_dirty_bitmap(BlockDriverState
*bs
)
447 if (bs
->drv
&& bs
->drv
->bdrv_supports_persistent_dirty_bitmap
) {
448 return bs
->drv
->bdrv_supports_persistent_dirty_bitmap(bs
);
453 static bool coroutine_fn
454 bdrv_co_can_store_new_dirty_bitmap(BlockDriverState
*bs
, const char *name
,
455 uint32_t granularity
, Error
**errp
)
457 BlockDriver
*drv
= bs
->drv
;
460 error_setg_errno(errp
, ENOMEDIUM
,
461 "Can't store persistent bitmaps to %s",
462 bdrv_get_device_or_node_name(bs
));
466 if (!drv
->bdrv_co_can_store_new_dirty_bitmap
) {
467 error_setg_errno(errp
, ENOTSUP
,
468 "Can't store persistent bitmaps to %s",
469 bdrv_get_device_or_node_name(bs
));
473 return drv
->bdrv_co_can_store_new_dirty_bitmap(bs
, name
, granularity
, errp
);
476 typedef struct BdrvCanStoreNewDirtyBitmapCo
{
477 BlockDriverState
*bs
;
479 uint32_t granularity
;
484 } BdrvCanStoreNewDirtyBitmapCo
;
486 static void coroutine_fn
bdrv_co_can_store_new_dirty_bitmap_entry(void *opaque
)
488 BdrvCanStoreNewDirtyBitmapCo
*s
= opaque
;
490 s
->ret
= bdrv_co_can_store_new_dirty_bitmap(s
->bs
, s
->name
, s
->granularity
,
492 s
->in_progress
= false;
496 bool bdrv_can_store_new_dirty_bitmap(BlockDriverState
*bs
, const char *name
,
497 uint32_t granularity
, Error
**errp
)
500 if (qemu_in_coroutine()) {
501 return bdrv_co_can_store_new_dirty_bitmap(bs
, name
, granularity
, errp
);
504 BdrvCanStoreNewDirtyBitmapCo s
= {
507 .granularity
= granularity
,
512 co
= qemu_coroutine_create(bdrv_co_can_store_new_dirty_bitmap_entry
,
514 bdrv_coroutine_enter(bs
, co
);
515 BDRV_POLL_WHILE(bs
, s
.in_progress
);
521 void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
523 bdrv_dirty_bitmaps_lock(bitmap
->bs
);
524 bitmap
->disabled
= true;
525 bdrv_dirty_bitmaps_unlock(bitmap
->bs
);
528 void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
530 bdrv_dirty_bitmaps_lock(bitmap
->bs
);
531 bdrv_enable_dirty_bitmap_locked(bitmap
);
532 bdrv_dirty_bitmaps_unlock(bitmap
->bs
);
535 BlockDirtyInfoList
*bdrv_query_dirty_bitmaps(BlockDriverState
*bs
)
538 BlockDirtyInfoList
*list
= NULL
;
539 BlockDirtyInfoList
**tail
= &list
;
541 bdrv_dirty_bitmaps_lock(bs
);
542 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
543 BlockDirtyInfo
*info
= g_new0(BlockDirtyInfo
, 1);
545 info
->count
= bdrv_get_dirty_count(bm
);
546 info
->granularity
= bdrv_dirty_bitmap_granularity(bm
);
547 info
->has_name
= !!bm
->name
;
548 info
->name
= g_strdup(bm
->name
);
549 info
->recording
= bdrv_dirty_bitmap_recording(bm
);
550 info
->busy
= bdrv_dirty_bitmap_busy(bm
);
551 info
->persistent
= bm
->persistent
;
552 info
->has_inconsistent
= bm
->inconsistent
;
553 info
->inconsistent
= bm
->inconsistent
;
554 QAPI_LIST_APPEND(tail
, info
);
556 bdrv_dirty_bitmaps_unlock(bs
);
561 /* Called within bdrv_dirty_bitmap_lock..unlock */
562 bool bdrv_dirty_bitmap_get_locked(BdrvDirtyBitmap
*bitmap
, int64_t offset
)
564 return hbitmap_get(bitmap
->bitmap
, offset
);
567 bool bdrv_dirty_bitmap_get(BdrvDirtyBitmap
*bitmap
, int64_t offset
)
570 bdrv_dirty_bitmaps_lock(bitmap
->bs
);
571 ret
= bdrv_dirty_bitmap_get_locked(bitmap
, offset
);
572 bdrv_dirty_bitmaps_unlock(bitmap
->bs
);
578 * Chooses a default granularity based on the existing cluster size,
579 * but clamped between [4K, 64K]. Defaults to 64K in the case that there
580 * is no cluster size information available.
582 uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState
*bs
)
585 uint32_t granularity
;
587 if (bdrv_get_info(bs
, &bdi
) >= 0 && bdi
.cluster_size
> 0) {
588 granularity
= MAX(4096, bdi
.cluster_size
);
589 granularity
= MIN(65536, granularity
);
597 uint32_t bdrv_dirty_bitmap_granularity(const BdrvDirtyBitmap
*bitmap
)
599 return 1U << hbitmap_granularity(bitmap
->bitmap
);
602 BdrvDirtyBitmapIter
*bdrv_dirty_iter_new(BdrvDirtyBitmap
*bitmap
)
604 BdrvDirtyBitmapIter
*iter
= g_new(BdrvDirtyBitmapIter
, 1);
605 hbitmap_iter_init(&iter
->hbi
, bitmap
->bitmap
, 0);
606 iter
->bitmap
= bitmap
;
607 bitmap
->active_iterators
++;
611 void bdrv_dirty_iter_free(BdrvDirtyBitmapIter
*iter
)
616 assert(iter
->bitmap
->active_iterators
> 0);
617 iter
->bitmap
->active_iterators
--;
621 int64_t bdrv_dirty_iter_next(BdrvDirtyBitmapIter
*iter
)
623 return hbitmap_iter_next(&iter
->hbi
);
626 /* Called within bdrv_dirty_bitmap_lock..unlock */
627 void bdrv_set_dirty_bitmap_locked(BdrvDirtyBitmap
*bitmap
,
628 int64_t offset
, int64_t bytes
)
630 assert(!bdrv_dirty_bitmap_readonly(bitmap
));
631 hbitmap_set(bitmap
->bitmap
, offset
, bytes
);
634 void bdrv_set_dirty_bitmap(BdrvDirtyBitmap
*bitmap
,
635 int64_t offset
, int64_t bytes
)
637 bdrv_dirty_bitmaps_lock(bitmap
->bs
);
638 bdrv_set_dirty_bitmap_locked(bitmap
, offset
, bytes
);
639 bdrv_dirty_bitmaps_unlock(bitmap
->bs
);
642 /* Called within bdrv_dirty_bitmap_lock..unlock */
643 void bdrv_reset_dirty_bitmap_locked(BdrvDirtyBitmap
*bitmap
,
644 int64_t offset
, int64_t bytes
)
646 assert(!bdrv_dirty_bitmap_readonly(bitmap
));
647 hbitmap_reset(bitmap
->bitmap
, offset
, bytes
);
650 void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap
*bitmap
,
651 int64_t offset
, int64_t bytes
)
653 bdrv_dirty_bitmaps_lock(bitmap
->bs
);
654 bdrv_reset_dirty_bitmap_locked(bitmap
, offset
, bytes
);
655 bdrv_dirty_bitmaps_unlock(bitmap
->bs
);
658 void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap
*bitmap
, HBitmap
**out
)
660 assert(!bdrv_dirty_bitmap_readonly(bitmap
));
661 bdrv_dirty_bitmaps_lock(bitmap
->bs
);
663 hbitmap_reset_all(bitmap
->bitmap
);
665 HBitmap
*backup
= bitmap
->bitmap
;
666 bitmap
->bitmap
= hbitmap_alloc(bitmap
->size
,
667 hbitmap_granularity(backup
));
670 bdrv_dirty_bitmaps_unlock(bitmap
->bs
);
673 void bdrv_restore_dirty_bitmap(BdrvDirtyBitmap
*bitmap
, HBitmap
*backup
)
675 HBitmap
*tmp
= bitmap
->bitmap
;
676 assert(!bdrv_dirty_bitmap_readonly(bitmap
));
678 bitmap
->bitmap
= backup
;
682 uint64_t bdrv_dirty_bitmap_serialization_size(const BdrvDirtyBitmap
*bitmap
,
683 uint64_t offset
, uint64_t bytes
)
685 return hbitmap_serialization_size(bitmap
->bitmap
, offset
, bytes
);
688 uint64_t bdrv_dirty_bitmap_serialization_align(const BdrvDirtyBitmap
*bitmap
)
690 return hbitmap_serialization_align(bitmap
->bitmap
);
693 /* Return the disk size covered by a chunk of serialized bitmap data. */
694 uint64_t bdrv_dirty_bitmap_serialization_coverage(int serialized_chunk_size
,
695 const BdrvDirtyBitmap
*bitmap
)
697 uint64_t granularity
= bdrv_dirty_bitmap_granularity(bitmap
);
698 uint64_t limit
= granularity
* (serialized_chunk_size
<< 3);
700 assert(QEMU_IS_ALIGNED(limit
,
701 bdrv_dirty_bitmap_serialization_align(bitmap
)));
706 void bdrv_dirty_bitmap_serialize_part(const BdrvDirtyBitmap
*bitmap
,
707 uint8_t *buf
, uint64_t offset
,
710 hbitmap_serialize_part(bitmap
->bitmap
, buf
, offset
, bytes
);
713 void bdrv_dirty_bitmap_deserialize_part(BdrvDirtyBitmap
*bitmap
,
714 uint8_t *buf
, uint64_t offset
,
715 uint64_t bytes
, bool finish
)
717 hbitmap_deserialize_part(bitmap
->bitmap
, buf
, offset
, bytes
, finish
);
720 void bdrv_dirty_bitmap_deserialize_zeroes(BdrvDirtyBitmap
*bitmap
,
721 uint64_t offset
, uint64_t bytes
,
724 hbitmap_deserialize_zeroes(bitmap
->bitmap
, offset
, bytes
, finish
);
727 void bdrv_dirty_bitmap_deserialize_ones(BdrvDirtyBitmap
*bitmap
,
728 uint64_t offset
, uint64_t bytes
,
731 hbitmap_deserialize_ones(bitmap
->bitmap
, offset
, bytes
, finish
);
734 void bdrv_dirty_bitmap_deserialize_finish(BdrvDirtyBitmap
*bitmap
)
736 hbitmap_deserialize_finish(bitmap
->bitmap
);
739 void bdrv_set_dirty(BlockDriverState
*bs
, int64_t offset
, int64_t bytes
)
741 BdrvDirtyBitmap
*bitmap
;
743 if (QLIST_EMPTY(&bs
->dirty_bitmaps
)) {
747 bdrv_dirty_bitmaps_lock(bs
);
748 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
749 if (!bdrv_dirty_bitmap_enabled(bitmap
)) {
752 assert(!bdrv_dirty_bitmap_readonly(bitmap
));
753 hbitmap_set(bitmap
->bitmap
, offset
, bytes
);
755 bdrv_dirty_bitmaps_unlock(bs
);
759 * Advance a BdrvDirtyBitmapIter to an arbitrary offset.
761 void bdrv_set_dirty_iter(BdrvDirtyBitmapIter
*iter
, int64_t offset
)
763 hbitmap_iter_init(&iter
->hbi
, iter
->hbi
.hb
, offset
);
766 int64_t bdrv_get_dirty_count(BdrvDirtyBitmap
*bitmap
)
768 return hbitmap_count(bitmap
->bitmap
);
771 bool bdrv_dirty_bitmap_readonly(const BdrvDirtyBitmap
*bitmap
)
773 return bitmap
->readonly
;
776 /* Called with BQL taken. */
777 void bdrv_dirty_bitmap_set_readonly(BdrvDirtyBitmap
*bitmap
, bool value
)
779 bdrv_dirty_bitmaps_lock(bitmap
->bs
);
780 bitmap
->readonly
= value
;
781 bdrv_dirty_bitmaps_unlock(bitmap
->bs
);
784 bool bdrv_has_readonly_bitmaps(BlockDriverState
*bs
)
787 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
796 bool bdrv_has_named_bitmaps(BlockDriverState
*bs
)
800 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
801 if (bdrv_dirty_bitmap_name(bm
)) {
809 /* Called with BQL taken. */
810 void bdrv_dirty_bitmap_set_persistence(BdrvDirtyBitmap
*bitmap
, bool persistent
)
812 bdrv_dirty_bitmaps_lock(bitmap
->bs
);
813 bitmap
->persistent
= persistent
;
814 bdrv_dirty_bitmaps_unlock(bitmap
->bs
);
817 /* Called with BQL taken. */
818 void bdrv_dirty_bitmap_set_inconsistent(BdrvDirtyBitmap
*bitmap
)
820 bdrv_dirty_bitmaps_lock(bitmap
->bs
);
821 assert(bitmap
->persistent
== true);
822 bitmap
->inconsistent
= true;
823 bitmap
->disabled
= true;
824 bdrv_dirty_bitmaps_unlock(bitmap
->bs
);
827 /* Called with BQL taken. */
828 void bdrv_dirty_bitmap_skip_store(BdrvDirtyBitmap
*bitmap
, bool skip
)
830 bdrv_dirty_bitmaps_lock(bitmap
->bs
);
831 bitmap
->skip_store
= skip
;
832 bdrv_dirty_bitmaps_unlock(bitmap
->bs
);
835 bool bdrv_dirty_bitmap_get_persistence(BdrvDirtyBitmap
*bitmap
)
837 return bitmap
->persistent
&& !bitmap
->skip_store
;
840 bool bdrv_dirty_bitmap_inconsistent(const BdrvDirtyBitmap
*bitmap
)
842 return bitmap
->inconsistent
;
845 BdrvDirtyBitmap
*bdrv_dirty_bitmap_first(BlockDriverState
*bs
)
847 return QLIST_FIRST(&bs
->dirty_bitmaps
);
850 BdrvDirtyBitmap
*bdrv_dirty_bitmap_next(BdrvDirtyBitmap
*bitmap
)
852 return QLIST_NEXT(bitmap
, list
);
855 char *bdrv_dirty_bitmap_sha256(const BdrvDirtyBitmap
*bitmap
, Error
**errp
)
857 return hbitmap_sha256(bitmap
->bitmap
, errp
);
860 int64_t bdrv_dirty_bitmap_next_dirty(BdrvDirtyBitmap
*bitmap
, int64_t offset
,
863 return hbitmap_next_dirty(bitmap
->bitmap
, offset
, bytes
);
866 int64_t bdrv_dirty_bitmap_next_zero(BdrvDirtyBitmap
*bitmap
, int64_t offset
,
869 return hbitmap_next_zero(bitmap
->bitmap
, offset
, bytes
);
872 bool bdrv_dirty_bitmap_next_dirty_area(BdrvDirtyBitmap
*bitmap
,
873 int64_t start
, int64_t end
, int64_t max_dirty_count
,
874 int64_t *dirty_start
, int64_t *dirty_count
)
876 return hbitmap_next_dirty_area(bitmap
->bitmap
, start
, end
, max_dirty_count
,
877 dirty_start
, dirty_count
);
881 * bdrv_merge_dirty_bitmap: merge src into dest.
882 * Ensures permissions on bitmaps are reasonable; use for public API.
884 * @backup: If provided, make a copy of dest here prior to merge.
886 void bdrv_merge_dirty_bitmap(BdrvDirtyBitmap
*dest
, const BdrvDirtyBitmap
*src
,
887 HBitmap
**backup
, Error
**errp
)
891 bdrv_dirty_bitmaps_lock(dest
->bs
);
892 if (src
->bs
!= dest
->bs
) {
893 bdrv_dirty_bitmaps_lock(src
->bs
);
896 if (bdrv_dirty_bitmap_check(dest
, BDRV_BITMAP_DEFAULT
, errp
)) {
900 if (bdrv_dirty_bitmap_check(src
, BDRV_BITMAP_ALLOW_RO
, errp
)) {
904 if (!hbitmap_can_merge(dest
->bitmap
, src
->bitmap
)) {
905 error_setg(errp
, "Bitmaps are incompatible and can't be merged");
909 ret
= bdrv_dirty_bitmap_merge_internal(dest
, src
, backup
, false);
913 bdrv_dirty_bitmaps_unlock(dest
->bs
);
914 if (src
->bs
!= dest
->bs
) {
915 bdrv_dirty_bitmaps_unlock(src
->bs
);
920 * bdrv_dirty_bitmap_merge_internal: merge src into dest.
921 * Does NOT check bitmap permissions; not suitable for use as public API.
923 * @backup: If provided, make a copy of dest here prior to merge.
924 * @lock: If true, lock and unlock bitmaps on the way in/out.
925 * returns true if the merge succeeded; false if unattempted.
927 bool bdrv_dirty_bitmap_merge_internal(BdrvDirtyBitmap
*dest
,
928 const BdrvDirtyBitmap
*src
,
934 assert(!bdrv_dirty_bitmap_readonly(dest
));
935 assert(!bdrv_dirty_bitmap_inconsistent(dest
));
936 assert(!bdrv_dirty_bitmap_inconsistent(src
));
939 bdrv_dirty_bitmaps_lock(dest
->bs
);
940 if (src
->bs
!= dest
->bs
) {
941 bdrv_dirty_bitmaps_lock(src
->bs
);
946 *backup
= dest
->bitmap
;
947 dest
->bitmap
= hbitmap_alloc(dest
->size
, hbitmap_granularity(*backup
));
948 ret
= hbitmap_merge(*backup
, src
->bitmap
, dest
->bitmap
);
950 ret
= hbitmap_merge(dest
->bitmap
, src
->bitmap
, dest
->bitmap
);
954 bdrv_dirty_bitmaps_unlock(dest
->bs
);
955 if (src
->bs
!= dest
->bs
) {
956 bdrv_dirty_bitmaps_unlock(src
->bs
);