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
));
677 bitmap
->bitmap
= backup
;
681 uint64_t bdrv_dirty_bitmap_serialization_size(const BdrvDirtyBitmap
*bitmap
,
682 uint64_t offset
, uint64_t bytes
)
684 return hbitmap_serialization_size(bitmap
->bitmap
, offset
, bytes
);
687 uint64_t bdrv_dirty_bitmap_serialization_align(const BdrvDirtyBitmap
*bitmap
)
689 return hbitmap_serialization_align(bitmap
->bitmap
);
692 /* Return the disk size covered by a chunk of serialized bitmap data. */
693 uint64_t bdrv_dirty_bitmap_serialization_coverage(int serialized_chunk_size
,
694 const BdrvDirtyBitmap
*bitmap
)
696 uint64_t granularity
= bdrv_dirty_bitmap_granularity(bitmap
);
697 uint64_t limit
= granularity
* (serialized_chunk_size
<< 3);
699 assert(QEMU_IS_ALIGNED(limit
,
700 bdrv_dirty_bitmap_serialization_align(bitmap
)));
705 void bdrv_dirty_bitmap_serialize_part(const BdrvDirtyBitmap
*bitmap
,
706 uint8_t *buf
, uint64_t offset
,
709 hbitmap_serialize_part(bitmap
->bitmap
, buf
, offset
, bytes
);
712 void bdrv_dirty_bitmap_deserialize_part(BdrvDirtyBitmap
*bitmap
,
713 uint8_t *buf
, uint64_t offset
,
714 uint64_t bytes
, bool finish
)
716 hbitmap_deserialize_part(bitmap
->bitmap
, buf
, offset
, bytes
, finish
);
719 void bdrv_dirty_bitmap_deserialize_zeroes(BdrvDirtyBitmap
*bitmap
,
720 uint64_t offset
, uint64_t bytes
,
723 hbitmap_deserialize_zeroes(bitmap
->bitmap
, offset
, bytes
, finish
);
726 void bdrv_dirty_bitmap_deserialize_ones(BdrvDirtyBitmap
*bitmap
,
727 uint64_t offset
, uint64_t bytes
,
730 hbitmap_deserialize_ones(bitmap
->bitmap
, offset
, bytes
, finish
);
733 void bdrv_dirty_bitmap_deserialize_finish(BdrvDirtyBitmap
*bitmap
)
735 hbitmap_deserialize_finish(bitmap
->bitmap
);
738 void bdrv_set_dirty(BlockDriverState
*bs
, int64_t offset
, int64_t bytes
)
740 BdrvDirtyBitmap
*bitmap
;
742 if (QLIST_EMPTY(&bs
->dirty_bitmaps
)) {
746 bdrv_dirty_bitmaps_lock(bs
);
747 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
748 if (!bdrv_dirty_bitmap_enabled(bitmap
)) {
751 assert(!bdrv_dirty_bitmap_readonly(bitmap
));
752 hbitmap_set(bitmap
->bitmap
, offset
, bytes
);
754 bdrv_dirty_bitmaps_unlock(bs
);
758 * Advance a BdrvDirtyBitmapIter to an arbitrary offset.
760 void bdrv_set_dirty_iter(BdrvDirtyBitmapIter
*iter
, int64_t offset
)
762 hbitmap_iter_init(&iter
->hbi
, iter
->hbi
.hb
, offset
);
765 int64_t bdrv_get_dirty_count(BdrvDirtyBitmap
*bitmap
)
767 return hbitmap_count(bitmap
->bitmap
);
770 bool bdrv_dirty_bitmap_readonly(const BdrvDirtyBitmap
*bitmap
)
772 return bitmap
->readonly
;
775 /* Called with BQL taken. */
776 void bdrv_dirty_bitmap_set_readonly(BdrvDirtyBitmap
*bitmap
, bool value
)
778 bdrv_dirty_bitmaps_lock(bitmap
->bs
);
779 bitmap
->readonly
= value
;
780 bdrv_dirty_bitmaps_unlock(bitmap
->bs
);
783 bool bdrv_has_readonly_bitmaps(BlockDriverState
*bs
)
786 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
795 bool bdrv_has_named_bitmaps(BlockDriverState
*bs
)
799 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
800 if (bdrv_dirty_bitmap_name(bm
)) {
808 /* Called with BQL taken. */
809 void bdrv_dirty_bitmap_set_persistence(BdrvDirtyBitmap
*bitmap
, bool persistent
)
811 bdrv_dirty_bitmaps_lock(bitmap
->bs
);
812 bitmap
->persistent
= persistent
;
813 bdrv_dirty_bitmaps_unlock(bitmap
->bs
);
816 /* Called with BQL taken. */
817 void bdrv_dirty_bitmap_set_inconsistent(BdrvDirtyBitmap
*bitmap
)
819 bdrv_dirty_bitmaps_lock(bitmap
->bs
);
820 assert(bitmap
->persistent
== true);
821 bitmap
->inconsistent
= true;
822 bitmap
->disabled
= true;
823 bdrv_dirty_bitmaps_unlock(bitmap
->bs
);
826 /* Called with BQL taken. */
827 void bdrv_dirty_bitmap_skip_store(BdrvDirtyBitmap
*bitmap
, bool skip
)
829 bdrv_dirty_bitmaps_lock(bitmap
->bs
);
830 bitmap
->skip_store
= skip
;
831 bdrv_dirty_bitmaps_unlock(bitmap
->bs
);
834 bool bdrv_dirty_bitmap_get_persistence(BdrvDirtyBitmap
*bitmap
)
836 return bitmap
->persistent
&& !bitmap
->skip_store
;
839 bool bdrv_dirty_bitmap_inconsistent(const BdrvDirtyBitmap
*bitmap
)
841 return bitmap
->inconsistent
;
844 BdrvDirtyBitmap
*bdrv_dirty_bitmap_first(BlockDriverState
*bs
)
846 return QLIST_FIRST(&bs
->dirty_bitmaps
);
849 BdrvDirtyBitmap
*bdrv_dirty_bitmap_next(BdrvDirtyBitmap
*bitmap
)
851 return QLIST_NEXT(bitmap
, list
);
854 char *bdrv_dirty_bitmap_sha256(const BdrvDirtyBitmap
*bitmap
, Error
**errp
)
856 return hbitmap_sha256(bitmap
->bitmap
, errp
);
859 int64_t bdrv_dirty_bitmap_next_dirty(BdrvDirtyBitmap
*bitmap
, int64_t offset
,
862 return hbitmap_next_dirty(bitmap
->bitmap
, offset
, bytes
);
865 int64_t bdrv_dirty_bitmap_next_zero(BdrvDirtyBitmap
*bitmap
, int64_t offset
,
868 return hbitmap_next_zero(bitmap
->bitmap
, offset
, bytes
);
871 bool bdrv_dirty_bitmap_next_dirty_area(BdrvDirtyBitmap
*bitmap
,
872 int64_t start
, int64_t end
, int64_t max_dirty_count
,
873 int64_t *dirty_start
, int64_t *dirty_count
)
875 return hbitmap_next_dirty_area(bitmap
->bitmap
, start
, end
, max_dirty_count
,
876 dirty_start
, dirty_count
);
880 * bdrv_merge_dirty_bitmap: merge src into dest.
881 * Ensures permissions on bitmaps are reasonable; use for public API.
883 * @backup: If provided, make a copy of dest here prior to merge.
885 void bdrv_merge_dirty_bitmap(BdrvDirtyBitmap
*dest
, const BdrvDirtyBitmap
*src
,
886 HBitmap
**backup
, Error
**errp
)
890 bdrv_dirty_bitmaps_lock(dest
->bs
);
891 if (src
->bs
!= dest
->bs
) {
892 bdrv_dirty_bitmaps_lock(src
->bs
);
895 if (bdrv_dirty_bitmap_check(dest
, BDRV_BITMAP_DEFAULT
, errp
)) {
899 if (bdrv_dirty_bitmap_check(src
, BDRV_BITMAP_ALLOW_RO
, errp
)) {
903 if (!hbitmap_can_merge(dest
->bitmap
, src
->bitmap
)) {
904 error_setg(errp
, "Bitmaps are incompatible and can't be merged");
908 ret
= bdrv_dirty_bitmap_merge_internal(dest
, src
, backup
, false);
912 bdrv_dirty_bitmaps_unlock(dest
->bs
);
913 if (src
->bs
!= dest
->bs
) {
914 bdrv_dirty_bitmaps_unlock(src
->bs
);
919 * bdrv_dirty_bitmap_merge_internal: merge src into dest.
920 * Does NOT check bitmap permissions; not suitable for use as public API.
922 * @backup: If provided, make a copy of dest here prior to merge.
923 * @lock: If true, lock and unlock bitmaps on the way in/out.
924 * returns true if the merge succeeded; false if unattempted.
926 bool bdrv_dirty_bitmap_merge_internal(BdrvDirtyBitmap
*dest
,
927 const BdrvDirtyBitmap
*src
,
933 assert(!bdrv_dirty_bitmap_readonly(dest
));
934 assert(!bdrv_dirty_bitmap_inconsistent(dest
));
935 assert(!bdrv_dirty_bitmap_inconsistent(src
));
938 bdrv_dirty_bitmaps_lock(dest
->bs
);
939 if (src
->bs
!= dest
->bs
) {
940 bdrv_dirty_bitmaps_lock(src
->bs
);
945 *backup
= dest
->bitmap
;
946 dest
->bitmap
= hbitmap_alloc(dest
->size
, hbitmap_granularity(*backup
));
947 ret
= hbitmap_merge(*backup
, src
->bitmap
, dest
->bitmap
);
949 ret
= hbitmap_merge(dest
->bitmap
, src
->bitmap
, dest
->bitmap
);
953 bdrv_dirty_bitmaps_unlock(dest
->bs
);
954 if (src
->bs
!= dest
->bs
) {
955 bdrv_dirty_bitmaps_unlock(src
->bs
);