1/*
2 * Block Dirty Bitmap
3 *
4 * Copyright (c) 2016-2017 Red Hat. Inc
5 *
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:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
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
22 * THE SOFTWARE.
23 */
24#include "qemu/osdep.h"
25#include "qapi/error.h"
26#include "trace.h"
27#include "block/block_int.h"
28#include "block/blockjob.h"
29
30struct BdrvDirtyBitmap {
31 QemuMutex *mutex;
32 HBitmap *bitmap; /* Dirty bitmap implementation */
33 HBitmap *meta; /* Meta dirty bitmap */
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
39 the device */
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
46 this flag is set. */
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
53 * inactivation. */
54 QLIST_ENTRY(BdrvDirtyBitmap) list;
55};
56
57struct BdrvDirtyBitmapIter {
58 HBitmapIter hbi;
59 BdrvDirtyBitmap *bitmap;
60};
61
62static inline void bdrv_dirty_bitmaps_lock(BlockDriverState *bs)
63{
64 qemu_mutex_lock(&bs->dirty_bitmap_mutex);
65}
66
67static inline void bdrv_dirty_bitmaps_unlock(BlockDriverState *bs)
68{
69 qemu_mutex_unlock(&bs->dirty_bitmap_mutex);
70}
71
72void bdrv_dirty_bitmap_lock(BdrvDirtyBitmap *bitmap)
73{
74 qemu_mutex_lock(bitmap->mutex);
75}
76
77void bdrv_dirty_bitmap_unlock(BdrvDirtyBitmap *bitmap)
78{
79 qemu_mutex_unlock(bitmap->mutex);
80}
81
82/* Called with BQL or dirty_bitmap lock taken. */
83BdrvDirtyBitmap *bdrv_find_dirty_bitmap(BlockDriverState *bs, const char *name)
84{
85 BdrvDirtyBitmap *bm;
86
87 assert(name);
88 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
89 if (bm->name && !strcmp(name, bm->name)) {
90 return bm;
91 }
92 }
93 return NULL;
94}
95
96/* Called with BQL taken. */
97BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs,
98 uint32_t granularity,
99 const char *name,
100 Error **errp)
101{
102 int64_t bitmap_size;
103 BdrvDirtyBitmap *bitmap;
104
105 assert(is_power_of_2(granularity) && granularity >= BDRV_SECTOR_SIZE);
106
107 if (name && bdrv_find_dirty_bitmap(bs, name)) {
108 error_setg(errp, "Bitmap already exists: %s", name);
109 return NULL;
110 }
111 bitmap_size = bdrv_getlength(bs);
112 if (bitmap_size < 0) {
113 error_setg_errno(errp, -bitmap_size, "could not get length of device");
114 errno = -bitmap_size;
115 return NULL;
116 }
117 bitmap = g_new0(BdrvDirtyBitmap, 1);
118 bitmap->mutex = &bs->dirty_bitmap_mutex;
119 bitmap->bitmap = hbitmap_alloc(bitmap_size, ctz32(granularity));
120 bitmap->size = bitmap_size;
121 bitmap->name = g_strdup(name);
122 bitmap->disabled = false;
123 bdrv_dirty_bitmaps_lock(bs);
124 QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list);
125 bdrv_dirty_bitmaps_unlock(bs);
126 return bitmap;
127}
128
129/* bdrv_create_meta_dirty_bitmap
130 *
131 * Create a meta dirty bitmap that tracks the changes of bits in @bitmap. I.e.
132 * when a dirty status bit in @bitmap is changed (either from reset to set or
133 * the other way around), its respective meta dirty bitmap bit will be marked
134 * dirty as well.
135 *
136 * @bitmap: the block dirty bitmap for which to create a meta dirty bitmap.
137 * @chunk_size: how many bytes of bitmap data does each bit in the meta bitmap
138 * track.
139 */
140void bdrv_create_meta_dirty_bitmap(BdrvDirtyBitmap *bitmap,
141 int chunk_size)
142{
143 assert(!bitmap->meta);
144 qemu_mutex_lock(bitmap->mutex);
145 bitmap->meta = hbitmap_create_meta(bitmap->bitmap,
146 chunk_size * BITS_PER_BYTE);
147 qemu_mutex_unlock(bitmap->mutex);
148}
149
150void bdrv_release_meta_dirty_bitmap(BdrvDirtyBitmap *bitmap)
151{
152 assert(bitmap->meta);
153 qemu_mutex_lock(bitmap->mutex);
154 hbitmap_free_meta(bitmap->bitmap);
155 bitmap->meta = NULL;
156 qemu_mutex_unlock(bitmap->mutex);
157}
158
159int64_t bdrv_dirty_bitmap_size(const BdrvDirtyBitmap *bitmap)
160{
161 return bitmap->size;
162}
163
164const char *bdrv_dirty_bitmap_name(const BdrvDirtyBitmap *bitmap)
165{
166 return bitmap->name;
167}
168
169/* Called with BQL taken. */
170bool bdrv_dirty_bitmap_has_successor(BdrvDirtyBitmap *bitmap)
171{
172 return bitmap->successor;
173}
174
175static bool bdrv_dirty_bitmap_busy(const BdrvDirtyBitmap *bitmap)
176{
177 return bitmap->busy;
178}
179
180void bdrv_dirty_bitmap_set_busy(BdrvDirtyBitmap *bitmap, bool busy)
181{
182 qemu_mutex_lock(bitmap->mutex);
183 bitmap->busy = busy;
184 qemu_mutex_unlock(bitmap->mutex);
185}
186
187/* Called with BQL taken. */
188bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap *bitmap)
189{
190 return !bitmap->disabled;
191}
192
193/**
194 * bdrv_dirty_bitmap_status: This API is now deprecated.
195 * Called with BQL taken.
196 *
197 * A BdrvDirtyBitmap can be in four possible user-visible states:
198 * (1) Active: successor is NULL, and disabled is false: full r/w mode
199 * (2) Disabled: successor is NULL, and disabled is true: qualified r/w mode,
200 * guest writes are dropped, but monitor writes are possible,
201 * through commands like merge and clear.
202 * (3) Frozen: successor is not NULL.
203 * A frozen bitmap cannot be renamed, deleted, cleared, set,
204 * enabled, merged to, etc. A frozen bitmap can only abdicate()
205 * or reclaim().
206 * In this state, the anonymous successor bitmap may be either
207 * Active and recording writes from the guest (e.g. backup jobs),
208 * or it can be Disabled and not recording writes.
209 * (4) Locked: Whether Active or Disabled, the user cannot modify this bitmap
210 * in any way from the monitor.
211 * (5) Inconsistent: This is a persistent bitmap whose "in use" bit is set, and
212 * is unusable by QEMU. It can be deleted to remove it from
213 * the qcow2.
214 */
215DirtyBitmapStatus bdrv_dirty_bitmap_status(BdrvDirtyBitmap *bitmap)
216{
217 if (bdrv_dirty_bitmap_inconsistent(bitmap)) {
218 return DIRTY_BITMAP_STATUS_INCONSISTENT;
219 } else if (bdrv_dirty_bitmap_has_successor(bitmap)) {
220 return DIRTY_BITMAP_STATUS_FROZEN;
221 } else if (bdrv_dirty_bitmap_busy(bitmap)) {
222 return DIRTY_BITMAP_STATUS_LOCKED;
223 } else if (!bdrv_dirty_bitmap_enabled(bitmap)) {
224 return DIRTY_BITMAP_STATUS_DISABLED;
225 } else {
226 return DIRTY_BITMAP_STATUS_ACTIVE;
227 }
228}
229
230/* Called with BQL taken. */
231static bool bdrv_dirty_bitmap_recording(BdrvDirtyBitmap *bitmap)
232{
233 return !bitmap->disabled || (bitmap->successor &&
234 !bitmap->successor->disabled);
235}
236
237int bdrv_dirty_bitmap_check(const BdrvDirtyBitmap *bitmap, uint32_t flags,
238 Error **errp)
239{
240 if ((flags & BDRV_BITMAP_BUSY) && bdrv_dirty_bitmap_busy(bitmap)) {
241 error_setg(errp, "Bitmap '%s' is currently in use by another"
242 " operation and cannot be used", bitmap->name);
243 return -1;
244 }
245
246 if ((flags & BDRV_BITMAP_RO) && bdrv_dirty_bitmap_readonly(bitmap)) {
247 error_setg(errp, "Bitmap '%s' is readonly and cannot be modified",
248 bitmap->name);
249 return -1;
250 }
251
252 if ((flags & BDRV_BITMAP_INCONSISTENT) &&
253 bdrv_dirty_bitmap_inconsistent(bitmap)) {
254 error_setg(errp, "Bitmap '%s' is inconsistent and cannot be used",
255 bitmap->name);
256 error_append_hint(errp, "Try block-dirty-bitmap-remove to delete"
257 " this bitmap from disk");
258 return -1;
259 }
260
261 return 0;
262}
263
264/**
265 * Create a successor bitmap destined to replace this bitmap after an operation.
266 * Requires that the bitmap is not marked busy and has no successor.
267 * The successor will be enabled if the parent bitmap was.
268 * Called with BQL taken.
269 */
270int bdrv_dirty_bitmap_create_successor(BlockDriverState *bs,
271 BdrvDirtyBitmap *bitmap, Error **errp)
272{
273 uint64_t granularity;
274 BdrvDirtyBitmap *child;
275
276 if (bdrv_dirty_bitmap_check(bitmap, BDRV_BITMAP_BUSY, errp)) {
277 return -1;
278 }
279 if (bdrv_dirty_bitmap_has_successor(bitmap)) {
280 error_setg(errp, "Cannot create a successor for a bitmap that already "
281 "has one");
282 return -1;
283 }
284
285 /* Create an anonymous successor */
286 granularity = bdrv_dirty_bitmap_granularity(bitmap);
287 child = bdrv_create_dirty_bitmap(bs, granularity, NULL, errp);
288 if (!child) {
289 return -1;
290 }
291
292 /* Successor will be on or off based on our current state. */
293 child->disabled = bitmap->disabled;
294 bitmap->disabled = true;
295
296 /* Install the successor and mark the parent as busy */
297 bitmap->successor = child;
298 bitmap->busy = true;
299 return 0;
300}
301
302void bdrv_enable_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap)
303{
304 bitmap->disabled = false;
305}
306
307/* Called with BQL taken. */
308void bdrv_dirty_bitmap_enable_successor(BdrvDirtyBitmap *bitmap)
309{
310 assert(bitmap->mutex == bitmap->successor->mutex);
311 qemu_mutex_lock(bitmap->mutex);
312 bdrv_enable_dirty_bitmap_locked(bitmap->successor);
313 qemu_mutex_unlock(bitmap->mutex);
314}
315
316/* Called within bdrv_dirty_bitmap_lock..unlock and with BQL taken. */
317static void bdrv_release_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap)
318{
319 assert(!bitmap->active_iterators);
320 assert(!bdrv_dirty_bitmap_busy(bitmap));
321 assert(!bdrv_dirty_bitmap_has_successor(bitmap));
322 assert(!bitmap->meta);
323 QLIST_REMOVE(bitmap, list);
324 hbitmap_free(bitmap->bitmap);
325 g_free(bitmap->name);
326 g_free(bitmap);
327}
328
329/**
330 * For a bitmap with a successor, yield our name to the successor,
331 * delete the old bitmap, and return a handle to the new bitmap.
332 * Called with BQL taken.
333 */
334BdrvDirtyBitmap *bdrv_dirty_bitmap_abdicate(BlockDriverState *bs,
335 BdrvDirtyBitmap *bitmap,
336 Error **errp)
337{
338 char *name;
339 BdrvDirtyBitmap *successor = bitmap->successor;
340
341 if (successor == NULL) {
342 error_setg(errp, "Cannot relinquish control if "
343 "there's no successor present");
344 return NULL;
345 }
346
347 name = bitmap->name;
348 bitmap->name = NULL;
349 successor->name = name;
350 bitmap->successor = NULL;
351 successor->persistent = bitmap->persistent;
352 bitmap->persistent = false;
353 bitmap->busy = false;
354 bdrv_release_dirty_bitmap(bs, bitmap);
355
356 return successor;
357}
358
359/**
360 * In cases of failure where we can no longer safely delete the parent,
361 * we may wish to re-join the parent and child/successor.
362 * The merged parent will be marked as not busy.
363 * The marged parent will be enabled if and only if the successor was enabled.
364 * Called within bdrv_dirty_bitmap_lock..unlock and with BQL taken.
365 */
366BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap_locked(BlockDriverState *bs,
367 BdrvDirtyBitmap *parent,
368 Error **errp)
369{
370 BdrvDirtyBitmap *successor = parent->successor;
371
372 if (!successor) {
373 error_setg(errp, "Cannot reclaim a successor when none is present");
374 return NULL;
375 }
376
377 if (!hbitmap_merge(parent->bitmap, successor->bitmap, parent->bitmap)) {
378 error_setg(errp, "Merging of parent and successor bitmap failed");
379 return NULL;
380 }
381
382 parent->disabled = successor->disabled;
383 parent->busy = false;
384 bdrv_release_dirty_bitmap_locked(successor);
385 parent->successor = NULL;
386
387 return parent;
388}
389
390/* Called with BQL taken. */
391BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap(BlockDriverState *bs,
392 BdrvDirtyBitmap *parent,
393 Error **errp)
394{
395 BdrvDirtyBitmap *ret;
396
397 qemu_mutex_lock(parent->mutex);
398 ret = bdrv_reclaim_dirty_bitmap_locked(bs, parent, errp);
399 qemu_mutex_unlock(parent->mutex);
400
401 return ret;
402}
403
404/**
405 * Truncates _all_ bitmaps attached to a BDS.
406 * Called with BQL taken.
407 */
408void bdrv_dirty_bitmap_truncate(BlockDriverState *bs, int64_t bytes)
409{
410 BdrvDirtyBitmap *bitmap;
411
412 bdrv_dirty_bitmaps_lock(bs);
413 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
414 assert(!bdrv_dirty_bitmap_busy(bitmap));
415 assert(!bdrv_dirty_bitmap_has_successor(bitmap));
416 assert(!bitmap->active_iterators);
417 hbitmap_truncate(bitmap->bitmap, bytes);
418 bitmap->size = bytes;
419 }
420 bdrv_dirty_bitmaps_unlock(bs);
421}
422
423/* Called with BQL taken. */
424void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
425{
426 bdrv_dirty_bitmaps_lock(bs);
427 bdrv_release_dirty_bitmap_locked(bitmap);
428 bdrv_dirty_bitmaps_unlock(bs);
429}
430
431/**
432 * Release all named dirty bitmaps attached to a BDS (for use in bdrv_close()).
433 * There must not be any busy bitmaps attached.
434 * This function does not remove persistent bitmaps from the storage.
435 * Called with BQL taken.
436 */
437void bdrv_release_named_dirty_bitmaps(BlockDriverState *bs)
438{
439 BdrvDirtyBitmap *bm, *next;
440
441 bdrv_dirty_bitmaps_lock(bs);
442 QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) {
443 if (bdrv_dirty_bitmap_name(bm)) {
444 bdrv_release_dirty_bitmap_locked(bm);
445 }
446 }
447 bdrv_dirty_bitmaps_unlock(bs);
448}
449
450/**
451 * Remove persistent dirty bitmap from the storage if it exists.
452 * Absence of bitmap is not an error, because we have the following scenario:
453 * BdrvDirtyBitmap can have .persistent = true but not yet saved and have no
454 * stored version. For such bitmap bdrv_remove_persistent_dirty_bitmap() should
455 * not fail.
456 * This function doesn't release corresponding BdrvDirtyBitmap.
457 */
458void bdrv_remove_persistent_dirty_bitmap(BlockDriverState *bs,
459 const char *name,
460 Error **errp)
461{
462 if (bs->drv && bs->drv->bdrv_remove_persistent_dirty_bitmap) {
463 bs->drv->bdrv_remove_persistent_dirty_bitmap(bs, name, errp);
464 }
465}
466
467void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
468{
469 bdrv_dirty_bitmap_lock(bitmap);
470 bitmap->disabled = true;
471 bdrv_dirty_bitmap_unlock(bitmap);
472}
473
474void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
475{
476 bdrv_dirty_bitmap_lock(bitmap);
477 bdrv_enable_dirty_bitmap_locked(bitmap);
478 bdrv_dirty_bitmap_unlock(bitmap);
479}
480
481BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs)
482{
483 BdrvDirtyBitmap *bm;
484 BlockDirtyInfoList *list = NULL;
485 BlockDirtyInfoList **plist = &list;
486
487 bdrv_dirty_bitmaps_lock(bs);
488 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
489 BlockDirtyInfo *info = g_new0(BlockDirtyInfo, 1);
490 BlockDirtyInfoList *entry = g_new0(BlockDirtyInfoList, 1);
491 info->count = bdrv_get_dirty_count(bm);
492 info->granularity = bdrv_dirty_bitmap_granularity(bm);
493 info->has_name = !!bm->name;
494 info->name = g_strdup(bm->name);
495 info->status = bdrv_dirty_bitmap_status(bm);
496 info->recording = bdrv_dirty_bitmap_recording(bm);
497 info->busy = bdrv_dirty_bitmap_busy(bm);
498 info->persistent = bm->persistent;
499 info->has_inconsistent = bm->inconsistent;
500 info->inconsistent = bm->inconsistent;
501 entry->value = info;
502 *plist = entry;
503 plist = &entry->next;
504 }
505 bdrv_dirty_bitmaps_unlock(bs);
506
507 return list;
508}
509
510/* Called within bdrv_dirty_bitmap_lock..unlock */
511bool bdrv_dirty_bitmap_get_locked(BdrvDirtyBitmap *bitmap, int64_t offset)
512{
513 return hbitmap_get(bitmap->bitmap, offset);
514}
515
516bool bdrv_dirty_bitmap_get(BdrvDirtyBitmap *bitmap, int64_t offset)
517{
518 bool ret;
519 bdrv_dirty_bitmap_lock(bitmap);
520 ret = bdrv_dirty_bitmap_get_locked(bitmap, offset);
521 bdrv_dirty_bitmap_unlock(bitmap);
522
523 return ret;
524}
525
526/**
527 * Chooses a default granularity based on the existing cluster size,
528 * but clamped between [4K, 64K]. Defaults to 64K in the case that there
529 * is no cluster size information available.
530 */
531uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState *bs)
532{
533 BlockDriverInfo bdi;
534 uint32_t granularity;
535
536 if (bdrv_get_info(bs, &bdi) >= 0 && bdi.cluster_size > 0) {
537 granularity = MAX(4096, bdi.cluster_size);
538 granularity = MIN(65536, granularity);
539 } else {
540 granularity = 65536;
541 }
542
543 return granularity;
544}
545
546uint32_t bdrv_dirty_bitmap_granularity(const BdrvDirtyBitmap *bitmap)
547{
548 return 1U << hbitmap_granularity(bitmap->bitmap);
549}
550
551BdrvDirtyBitmapIter *bdrv_dirty_iter_new(BdrvDirtyBitmap *bitmap)
552{
553 BdrvDirtyBitmapIter *iter = g_new(BdrvDirtyBitmapIter, 1);
554 hbitmap_iter_init(&iter->hbi, bitmap->bitmap, 0);
555 iter->bitmap = bitmap;
556 bitmap->active_iterators++;
557 return iter;
558}
559
560BdrvDirtyBitmapIter *bdrv_dirty_meta_iter_new(BdrvDirtyBitmap *bitmap)
561{
562 BdrvDirtyBitmapIter *iter = g_new(BdrvDirtyBitmapIter, 1);
563 hbitmap_iter_init(&iter->hbi, bitmap->meta, 0);
564 iter->bitmap = bitmap;
565 bitmap->active_iterators++;
566 return iter;
567}
568
569void bdrv_dirty_iter_free(BdrvDirtyBitmapIter *iter)
570{
571 if (!iter) {
572 return;
573 }
574 assert(iter->bitmap->active_iterators > 0);
575 iter->bitmap->active_iterators--;
576 g_free(iter);
577}
578
579int64_t bdrv_dirty_iter_next(BdrvDirtyBitmapIter *iter)
580{
581 return hbitmap_iter_next(&iter->hbi);
582}
583
584/* Called within bdrv_dirty_bitmap_lock..unlock */
585void bdrv_set_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap,
586 int64_t offset, int64_t bytes)
587{
588 assert(!bdrv_dirty_bitmap_readonly(bitmap));
589 hbitmap_set(bitmap->bitmap, offset, bytes);
590}
591
592void bdrv_set_dirty_bitmap(BdrvDirtyBitmap *bitmap,
593 int64_t offset, int64_t bytes)
594{
595 bdrv_dirty_bitmap_lock(bitmap);
596 bdrv_set_dirty_bitmap_locked(bitmap, offset, bytes);
597 bdrv_dirty_bitmap_unlock(bitmap);
598}
599
600/* Called within bdrv_dirty_bitmap_lock..unlock */
601void bdrv_reset_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap,
602 int64_t offset, int64_t bytes)
603{
604 assert(!bdrv_dirty_bitmap_readonly(bitmap));
605 hbitmap_reset(bitmap->bitmap, offset, bytes);
606}
607
608void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap *bitmap,
609 int64_t offset, int64_t bytes)
610{
611 bdrv_dirty_bitmap_lock(bitmap);
612 bdrv_reset_dirty_bitmap_locked(bitmap, offset, bytes);
613 bdrv_dirty_bitmap_unlock(bitmap);
614}
615
616void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap **out)
617{
618 assert(!bdrv_dirty_bitmap_readonly(bitmap));
619 bdrv_dirty_bitmap_lock(bitmap);
620 if (!out) {
621 hbitmap_reset_all(bitmap->bitmap);
622 } else {
623 HBitmap *backup = bitmap->bitmap;
624 bitmap->bitmap = hbitmap_alloc(bitmap->size,
625 hbitmap_granularity(backup));
626 *out = backup;
627 }
628 bdrv_dirty_bitmap_unlock(bitmap);
629}
630
631void bdrv_restore_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap *backup)
632{
633 HBitmap *tmp = bitmap->bitmap;
634 assert(!bdrv_dirty_bitmap_readonly(bitmap));
635 bitmap->bitmap = backup;
636 hbitmap_free(tmp);
637}
638
639uint64_t bdrv_dirty_bitmap_serialization_size(const BdrvDirtyBitmap *bitmap,
640 uint64_t offset, uint64_t bytes)
641{
642 return hbitmap_serialization_size(bitmap->bitmap, offset, bytes);
643}
644
645uint64_t bdrv_dirty_bitmap_serialization_align(const BdrvDirtyBitmap *bitmap)
646{
647 return hbitmap_serialization_align(bitmap->bitmap);
648}
649
650void bdrv_dirty_bitmap_serialize_part(const BdrvDirtyBitmap *bitmap,
651 uint8_t *buf, uint64_t offset,
652 uint64_t bytes)
653{
654 hbitmap_serialize_part(bitmap->bitmap, buf, offset, bytes);
655}
656
657void bdrv_dirty_bitmap_deserialize_part(BdrvDirtyBitmap *bitmap,
658 uint8_t *buf, uint64_t offset,
659 uint64_t bytes, bool finish)
660{
661 hbitmap_deserialize_part(bitmap->bitmap, buf, offset, bytes, finish);
662}
663
664void bdrv_dirty_bitmap_deserialize_zeroes(BdrvDirtyBitmap *bitmap,
665 uint64_t offset, uint64_t bytes,
666 bool finish)
667{
668 hbitmap_deserialize_zeroes(bitmap->bitmap, offset, bytes, finish);
669}
670
671void bdrv_dirty_bitmap_deserialize_ones(BdrvDirtyBitmap *bitmap,
672 uint64_t offset, uint64_t bytes,
673 bool finish)
674{
675 hbitmap_deserialize_ones(bitmap->bitmap, offset, bytes, finish);
676}
677
678void bdrv_dirty_bitmap_deserialize_finish(BdrvDirtyBitmap *bitmap)
679{
680 hbitmap_deserialize_finish(bitmap->bitmap);
681}
682
683void bdrv_set_dirty(BlockDriverState *bs, int64_t offset, int64_t bytes)
684{
685 BdrvDirtyBitmap *bitmap;
686
687 if (QLIST_EMPTY(&bs->dirty_bitmaps)) {
688 return;
689 }
690
691 bdrv_dirty_bitmaps_lock(bs);
692 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
693 if (!bdrv_dirty_bitmap_enabled(bitmap)) {
694 continue;
695 }
696 assert(!bdrv_dirty_bitmap_readonly(bitmap));
697 hbitmap_set(bitmap->bitmap, offset, bytes);
698 }
699 bdrv_dirty_bitmaps_unlock(bs);
700}
701
702/**
703 * Advance a BdrvDirtyBitmapIter to an arbitrary offset.
704 */
705void bdrv_set_dirty_iter(BdrvDirtyBitmapIter *iter, int64_t offset)
706{
707 hbitmap_iter_init(&iter->hbi, iter->hbi.hb, offset);
708}
709
710int64_t bdrv_get_dirty_count(BdrvDirtyBitmap *bitmap)
711{
712 return hbitmap_count(bitmap->bitmap);
713}
714
715int64_t bdrv_get_meta_dirty_count(BdrvDirtyBitmap *bitmap)
716{
717 return hbitmap_count(bitmap->meta);
718}
719
720bool bdrv_dirty_bitmap_readonly(const BdrvDirtyBitmap *bitmap)
721{
722 return bitmap->readonly;
723}
724
725/* Called with BQL taken. */
726void bdrv_dirty_bitmap_set_readonly(BdrvDirtyBitmap *bitmap, bool value)
727{
728 qemu_mutex_lock(bitmap->mutex);
729 bitmap->readonly = value;
730 qemu_mutex_unlock(bitmap->mutex);
731}
732
733bool bdrv_has_readonly_bitmaps(BlockDriverState *bs)
734{
735 BdrvDirtyBitmap *bm;
736 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
737 if (bm->readonly) {
738 return true;
739 }
740 }
741
742 return false;
743}
744
745/* Called with BQL taken. */
746void bdrv_dirty_bitmap_set_persistence(BdrvDirtyBitmap *bitmap, bool persistent)
747{
748 qemu_mutex_lock(bitmap->mutex);
749 bitmap->persistent = persistent;
750 qemu_mutex_unlock(bitmap->mutex);
751}
752
753/* Called with BQL taken. */
754void bdrv_dirty_bitmap_set_inconsistent(BdrvDirtyBitmap *bitmap)
755{
756 qemu_mutex_lock(bitmap->mutex);
757 assert(bitmap->persistent == true);
758 bitmap->inconsistent = true;
759 bitmap->disabled = true;
760 qemu_mutex_unlock(bitmap->mutex);
761}
762
763/* Called with BQL taken. */
764void bdrv_dirty_bitmap_skip_store(BdrvDirtyBitmap *bitmap, bool skip)
765{
766 qemu_mutex_lock(bitmap->mutex);
767 bitmap->skip_store = skip;
768 qemu_mutex_unlock(bitmap->mutex);
769}
770
771bool bdrv_dirty_bitmap_get_persistence(BdrvDirtyBitmap *bitmap)
772{
773 return bitmap->persistent && !bitmap->skip_store;
774}
775
776bool bdrv_dirty_bitmap_inconsistent(const BdrvDirtyBitmap *bitmap)
777{
778 return bitmap->inconsistent;
779}
780
781bool bdrv_has_changed_persistent_bitmaps(BlockDriverState *bs)
782{
783 BdrvDirtyBitmap *bm;
784 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
785 if (bm->persistent && !bm->readonly && !bm->skip_store) {
786 return true;
787 }
788 }
789
790 return false;
791}
792
793BdrvDirtyBitmap *bdrv_dirty_bitmap_next(BlockDriverState *bs,
794 BdrvDirtyBitmap *bitmap)
795{
796 return bitmap == NULL ? QLIST_FIRST(&bs->dirty_bitmaps) :
797 QLIST_NEXT(bitmap, list);
798}
799
800char *bdrv_dirty_bitmap_sha256(const BdrvDirtyBitmap *bitmap, Error **errp)
801{
802 return hbitmap_sha256(bitmap->bitmap, errp);
803}
804
805int64_t bdrv_dirty_bitmap_next_zero(BdrvDirtyBitmap *bitmap, uint64_t offset,
806 uint64_t bytes)
807{
808 return hbitmap_next_zero(bitmap->bitmap, offset, bytes);
809}
810
811bool bdrv_dirty_bitmap_next_dirty_area(BdrvDirtyBitmap *bitmap,
812 uint64_t *offset, uint64_t *bytes)
813{
814 return hbitmap_next_dirty_area(bitmap->bitmap, offset, bytes);
815}
816
817/**
818 * bdrv_merge_dirty_bitmap: merge src into dest.
819 * Ensures permissions on bitmaps are reasonable; use for public API.
820 *
821 * @backup: If provided, make a copy of dest here prior to merge.
822 */
823void bdrv_merge_dirty_bitmap(BdrvDirtyBitmap *dest, const BdrvDirtyBitmap *src,
824 HBitmap **backup, Error **errp)
825{
826 bool ret;
827
828 qemu_mutex_lock(dest->mutex);
829 if (src->mutex != dest->mutex) {
830 qemu_mutex_lock(src->mutex);
831 }
832
833 if (bdrv_dirty_bitmap_check(dest, BDRV_BITMAP_DEFAULT, errp)) {
834 goto out;
835 }
836
837 if (bdrv_dirty_bitmap_check(src, BDRV_BITMAP_ALLOW_RO, errp)) {
838 goto out;
839 }
840
841 if (!hbitmap_can_merge(dest->bitmap, src->bitmap)) {
842 error_setg(errp, "Bitmaps are incompatible and can't be merged");
843 goto out;
844 }
845
846 ret = bdrv_dirty_bitmap_merge_internal(dest, src, backup, false);
847 assert(ret);
848
849out:
850 qemu_mutex_unlock(dest->mutex);
851 if (src->mutex != dest->mutex) {
852 qemu_mutex_unlock(src->mutex);
853 }
854}
855
856/**
857 * bdrv_dirty_bitmap_merge_internal: merge src into dest.
858 * Does NOT check bitmap permissions; not suitable for use as public API.
859 *
860 * @backup: If provided, make a copy of dest here prior to merge.
861 * @lock: If true, lock and unlock bitmaps on the way in/out.
862 * returns true if the merge succeeded; false if unattempted.
863 */
864bool bdrv_dirty_bitmap_merge_internal(BdrvDirtyBitmap *dest,
865 const BdrvDirtyBitmap *src,
866 HBitmap **backup,
867 bool lock)
868{
869 bool ret;
870
871 assert(!bdrv_dirty_bitmap_readonly(dest));
872 assert(!bdrv_dirty_bitmap_inconsistent(dest));
873 assert(!bdrv_dirty_bitmap_inconsistent(src));
874
875 if (lock) {
876 qemu_mutex_lock(dest->mutex);
877 if (src->mutex != dest->mutex) {
878 qemu_mutex_lock(src->mutex);
879 }
880 }
881
882 if (backup) {
883 *backup = dest->bitmap;
884 dest->bitmap = hbitmap_alloc(dest->size, hbitmap_granularity(*backup));
885 ret = hbitmap_merge(*backup, src->bitmap, dest->bitmap);
886 } else {
887 ret = hbitmap_merge(dest->bitmap, src->bitmap, dest->bitmap);
888 }
889
890 if (lock) {
891 qemu_mutex_unlock(dest->mutex);
892 if (src->mutex != dest->mutex) {
893 qemu_mutex_unlock(src->mutex);
894 }
895 }
896
897 return ret;
898}
899