1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include "qemu/osdep.h"
25#include "qapi/error.h"
26#include "qemu-common.h"
27#include "trace.h"
28#include "block/block_int.h"
29#include "block/blockjob.h"
30
31
32
33
34
35
36
37
38
39struct BdrvDirtyBitmap {
40 QemuMutex *mutex;
41 HBitmap *bitmap;
42 HBitmap *meta;
43 BdrvDirtyBitmap *successor;
44 char *name;
45 int64_t size;
46 bool disabled;
47
48 int active_iterators;
49 bool readonly;
50
51
52
53
54
55 bool autoload;
56
57 bool persistent;
58 QLIST_ENTRY(BdrvDirtyBitmap) list;
59};
60
61struct BdrvDirtyBitmapIter {
62 HBitmapIter hbi;
63 BdrvDirtyBitmap *bitmap;
64};
65
66static inline void bdrv_dirty_bitmaps_lock(BlockDriverState *bs)
67{
68 qemu_mutex_lock(&bs->dirty_bitmap_mutex);
69}
70
71static inline void bdrv_dirty_bitmaps_unlock(BlockDriverState *bs)
72{
73 qemu_mutex_unlock(&bs->dirty_bitmap_mutex);
74}
75
76void bdrv_dirty_bitmap_lock(BdrvDirtyBitmap *bitmap)
77{
78 qemu_mutex_lock(bitmap->mutex);
79}
80
81void bdrv_dirty_bitmap_unlock(BdrvDirtyBitmap *bitmap)
82{
83 qemu_mutex_unlock(bitmap->mutex);
84}
85
86
87BdrvDirtyBitmap *bdrv_find_dirty_bitmap(BlockDriverState *bs, const char *name)
88{
89 BdrvDirtyBitmap *bm;
90
91 assert(name);
92 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
93 if (bm->name && !strcmp(name, bm->name)) {
94 return bm;
95 }
96 }
97 return NULL;
98}
99
100
101void bdrv_dirty_bitmap_make_anon(BdrvDirtyBitmap *bitmap)
102{
103 assert(!bdrv_dirty_bitmap_frozen(bitmap));
104 g_free(bitmap->name);
105 bitmap->name = NULL;
106 bitmap->persistent = false;
107 bitmap->autoload = false;
108}
109
110
111BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs,
112 uint32_t granularity,
113 const char *name,
114 Error **errp)
115{
116 int64_t bitmap_size;
117 BdrvDirtyBitmap *bitmap;
118 uint32_t sector_granularity;
119
120 assert((granularity & (granularity - 1)) == 0);
121
122 if (name && bdrv_find_dirty_bitmap(bs, name)) {
123 error_setg(errp, "Bitmap already exists: %s", name);
124 return NULL;
125 }
126 sector_granularity = granularity >> BDRV_SECTOR_BITS;
127 assert(sector_granularity);
128 bitmap_size = bdrv_nb_sectors(bs);
129 if (bitmap_size < 0) {
130 error_setg_errno(errp, -bitmap_size, "could not get length of device");
131 errno = -bitmap_size;
132 return NULL;
133 }
134 bitmap = g_new0(BdrvDirtyBitmap, 1);
135 bitmap->mutex = &bs->dirty_bitmap_mutex;
136 bitmap->bitmap = hbitmap_alloc(bitmap_size, ctz32(sector_granularity));
137 bitmap->size = bitmap_size;
138 bitmap->name = g_strdup(name);
139 bitmap->disabled = false;
140 bdrv_dirty_bitmaps_lock(bs);
141 QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list);
142 bdrv_dirty_bitmaps_unlock(bs);
143 return bitmap;
144}
145
146
147
148
149
150
151
152
153
154
155
156
157void bdrv_create_meta_dirty_bitmap(BdrvDirtyBitmap *bitmap,
158 int chunk_size)
159{
160 assert(!bitmap->meta);
161 qemu_mutex_lock(bitmap->mutex);
162 bitmap->meta = hbitmap_create_meta(bitmap->bitmap,
163 chunk_size * BITS_PER_BYTE);
164 qemu_mutex_unlock(bitmap->mutex);
165}
166
167void bdrv_release_meta_dirty_bitmap(BdrvDirtyBitmap *bitmap)
168{
169 assert(bitmap->meta);
170 qemu_mutex_lock(bitmap->mutex);
171 hbitmap_free_meta(bitmap->bitmap);
172 bitmap->meta = NULL;
173 qemu_mutex_unlock(bitmap->mutex);
174}
175
176int bdrv_dirty_bitmap_get_meta_locked(BlockDriverState *bs,
177 BdrvDirtyBitmap *bitmap, int64_t sector,
178 int nb_sectors)
179{
180 uint64_t i;
181 int sectors_per_bit = 1 << hbitmap_granularity(bitmap->meta);
182
183
184
185 for (i = sector; i < sector + nb_sectors; i += sectors_per_bit) {
186 if (hbitmap_get(bitmap->meta, i)) {
187 return true;
188 }
189 }
190 return false;
191}
192
193int bdrv_dirty_bitmap_get_meta(BlockDriverState *bs,
194 BdrvDirtyBitmap *bitmap, int64_t sector,
195 int nb_sectors)
196{
197 bool dirty;
198
199 qemu_mutex_lock(bitmap->mutex);
200 dirty = bdrv_dirty_bitmap_get_meta_locked(bs, bitmap, sector, nb_sectors);
201 qemu_mutex_unlock(bitmap->mutex);
202
203 return dirty;
204}
205
206void bdrv_dirty_bitmap_reset_meta(BlockDriverState *bs,
207 BdrvDirtyBitmap *bitmap, int64_t sector,
208 int nb_sectors)
209{
210 qemu_mutex_lock(bitmap->mutex);
211 hbitmap_reset(bitmap->meta, sector, nb_sectors);
212 qemu_mutex_unlock(bitmap->mutex);
213}
214
215int64_t bdrv_dirty_bitmap_size(const BdrvDirtyBitmap *bitmap)
216{
217 return bitmap->size;
218}
219
220const char *bdrv_dirty_bitmap_name(const BdrvDirtyBitmap *bitmap)
221{
222 return bitmap->name;
223}
224
225
226bool bdrv_dirty_bitmap_frozen(BdrvDirtyBitmap *bitmap)
227{
228 return bitmap->successor;
229}
230
231
232bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap *bitmap)
233{
234 return !(bitmap->disabled || bitmap->successor);
235}
236
237
238DirtyBitmapStatus bdrv_dirty_bitmap_status(BdrvDirtyBitmap *bitmap)
239{
240 if (bdrv_dirty_bitmap_frozen(bitmap)) {
241 return DIRTY_BITMAP_STATUS_FROZEN;
242 } else if (!bdrv_dirty_bitmap_enabled(bitmap)) {
243 return DIRTY_BITMAP_STATUS_DISABLED;
244 } else {
245 return DIRTY_BITMAP_STATUS_ACTIVE;
246 }
247}
248
249
250
251
252
253
254int bdrv_dirty_bitmap_create_successor(BlockDriverState *bs,
255 BdrvDirtyBitmap *bitmap, Error **errp)
256{
257 uint64_t granularity;
258 BdrvDirtyBitmap *child;
259
260 if (bdrv_dirty_bitmap_frozen(bitmap)) {
261 error_setg(errp, "Cannot create a successor for a bitmap that is "
262 "currently frozen");
263 return -1;
264 }
265 assert(!bitmap->successor);
266
267
268 granularity = bdrv_dirty_bitmap_granularity(bitmap);
269 child = bdrv_create_dirty_bitmap(bs, granularity, NULL, errp);
270 if (!child) {
271 return -1;
272 }
273
274
275 child->disabled = bitmap->disabled;
276
277
278 bitmap->successor = child;
279 return 0;
280}
281
282
283
284
285
286
287BdrvDirtyBitmap *bdrv_dirty_bitmap_abdicate(BlockDriverState *bs,
288 BdrvDirtyBitmap *bitmap,
289 Error **errp)
290{
291 char *name;
292 BdrvDirtyBitmap *successor = bitmap->successor;
293
294 if (successor == NULL) {
295 error_setg(errp, "Cannot relinquish control if "
296 "there's no successor present");
297 return NULL;
298 }
299
300 name = bitmap->name;
301 bitmap->name = NULL;
302 successor->name = name;
303 bitmap->successor = NULL;
304 successor->persistent = bitmap->persistent;
305 bitmap->persistent = false;
306 successor->autoload = bitmap->autoload;
307 bitmap->autoload = false;
308 bdrv_release_dirty_bitmap(bs, bitmap);
309
310 return successor;
311}
312
313
314
315
316
317
318
319BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap(BlockDriverState *bs,
320 BdrvDirtyBitmap *parent,
321 Error **errp)
322{
323 BdrvDirtyBitmap *successor = parent->successor;
324
325 if (!successor) {
326 error_setg(errp, "Cannot reclaim a successor when none is present");
327 return NULL;
328 }
329
330 if (!hbitmap_merge(parent->bitmap, successor->bitmap)) {
331 error_setg(errp, "Merging of parent and successor bitmap failed");
332 return NULL;
333 }
334 bdrv_release_dirty_bitmap(bs, successor);
335 parent->successor = NULL;
336
337 return parent;
338}
339
340
341
342
343
344void bdrv_dirty_bitmap_truncate(BlockDriverState *bs)
345{
346 BdrvDirtyBitmap *bitmap;
347 uint64_t size = bdrv_nb_sectors(bs);
348
349 bdrv_dirty_bitmaps_lock(bs);
350 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
351 assert(!bdrv_dirty_bitmap_frozen(bitmap));
352 assert(!bitmap->active_iterators);
353 hbitmap_truncate(bitmap->bitmap, size);
354 bitmap->size = size;
355 }
356 bdrv_dirty_bitmaps_unlock(bs);
357}
358
359static bool bdrv_dirty_bitmap_has_name(BdrvDirtyBitmap *bitmap)
360{
361 return !!bdrv_dirty_bitmap_name(bitmap);
362}
363
364
365static void bdrv_do_release_matching_dirty_bitmap(
366 BlockDriverState *bs, BdrvDirtyBitmap *bitmap,
367 bool (*cond)(BdrvDirtyBitmap *bitmap))
368{
369 BdrvDirtyBitmap *bm, *next;
370 bdrv_dirty_bitmaps_lock(bs);
371 QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) {
372 if ((!bitmap || bm == bitmap) && (!cond || cond(bm))) {
373 assert(!bm->active_iterators);
374 assert(!bdrv_dirty_bitmap_frozen(bm));
375 assert(!bm->meta);
376 QLIST_REMOVE(bm, list);
377 hbitmap_free(bm->bitmap);
378 g_free(bm->name);
379 g_free(bm);
380
381 if (bitmap) {
382 goto out;
383 }
384 }
385 }
386 if (bitmap) {
387 abort();
388 }
389
390out:
391 bdrv_dirty_bitmaps_unlock(bs);
392}
393
394
395void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
396{
397 bdrv_do_release_matching_dirty_bitmap(bs, bitmap, NULL);
398}
399
400
401
402
403
404
405
406void bdrv_release_named_dirty_bitmaps(BlockDriverState *bs)
407{
408 bdrv_do_release_matching_dirty_bitmap(bs, NULL, bdrv_dirty_bitmap_has_name);
409}
410
411
412
413
414
415
416
417void bdrv_release_persistent_dirty_bitmaps(BlockDriverState *bs)
418{
419 bdrv_do_release_matching_dirty_bitmap(bs, NULL,
420 bdrv_dirty_bitmap_get_persistance);
421}
422
423
424
425
426
427
428
429
430
431void bdrv_remove_persistent_dirty_bitmap(BlockDriverState *bs,
432 const char *name,
433 Error **errp)
434{
435 if (bs->drv && bs->drv->bdrv_remove_persistent_dirty_bitmap) {
436 bs->drv->bdrv_remove_persistent_dirty_bitmap(bs, name, errp);
437 }
438}
439
440
441void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
442{
443 assert(!bdrv_dirty_bitmap_frozen(bitmap));
444 bitmap->disabled = true;
445}
446
447
448void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
449{
450 assert(!bdrv_dirty_bitmap_frozen(bitmap));
451 bitmap->disabled = false;
452}
453
454BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs)
455{
456 BdrvDirtyBitmap *bm;
457 BlockDirtyInfoList *list = NULL;
458 BlockDirtyInfoList **plist = &list;
459
460 bdrv_dirty_bitmaps_lock(bs);
461 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
462 BlockDirtyInfo *info = g_new0(BlockDirtyInfo, 1);
463 BlockDirtyInfoList *entry = g_new0(BlockDirtyInfoList, 1);
464 info->count = bdrv_get_dirty_count(bm) << BDRV_SECTOR_BITS;
465 info->granularity = bdrv_dirty_bitmap_granularity(bm);
466 info->has_name = !!bm->name;
467 info->name = g_strdup(bm->name);
468 info->status = bdrv_dirty_bitmap_status(bm);
469 entry->value = info;
470 *plist = entry;
471 plist = &entry->next;
472 }
473 bdrv_dirty_bitmaps_unlock(bs);
474
475 return list;
476}
477
478
479int bdrv_get_dirty_locked(BlockDriverState *bs, BdrvDirtyBitmap *bitmap,
480 int64_t sector)
481{
482 if (bitmap) {
483 return hbitmap_get(bitmap->bitmap, sector);
484 } else {
485 return 0;
486 }
487}
488
489
490
491
492
493
494uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState *bs)
495{
496 BlockDriverInfo bdi;
497 uint32_t granularity;
498
499 if (bdrv_get_info(bs, &bdi) >= 0 && bdi.cluster_size > 0) {
500 granularity = MAX(4096, bdi.cluster_size);
501 granularity = MIN(65536, granularity);
502 } else {
503 granularity = 65536;
504 }
505
506 return granularity;
507}
508
509uint32_t bdrv_dirty_bitmap_granularity(const BdrvDirtyBitmap *bitmap)
510{
511 return BDRV_SECTOR_SIZE << hbitmap_granularity(bitmap->bitmap);
512}
513
514uint32_t bdrv_dirty_bitmap_meta_granularity(BdrvDirtyBitmap *bitmap)
515{
516 return BDRV_SECTOR_SIZE << hbitmap_granularity(bitmap->meta);
517}
518
519BdrvDirtyBitmapIter *bdrv_dirty_iter_new(BdrvDirtyBitmap *bitmap,
520 uint64_t first_sector)
521{
522 BdrvDirtyBitmapIter *iter = g_new(BdrvDirtyBitmapIter, 1);
523 hbitmap_iter_init(&iter->hbi, bitmap->bitmap, first_sector);
524 iter->bitmap = bitmap;
525 bitmap->active_iterators++;
526 return iter;
527}
528
529BdrvDirtyBitmapIter *bdrv_dirty_meta_iter_new(BdrvDirtyBitmap *bitmap)
530{
531 BdrvDirtyBitmapIter *iter = g_new(BdrvDirtyBitmapIter, 1);
532 hbitmap_iter_init(&iter->hbi, bitmap->meta, 0);
533 iter->bitmap = bitmap;
534 bitmap->active_iterators++;
535 return iter;
536}
537
538void bdrv_dirty_iter_free(BdrvDirtyBitmapIter *iter)
539{
540 if (!iter) {
541 return;
542 }
543 assert(iter->bitmap->active_iterators > 0);
544 iter->bitmap->active_iterators--;
545 g_free(iter);
546}
547
548int64_t bdrv_dirty_iter_next(BdrvDirtyBitmapIter *iter)
549{
550 return hbitmap_iter_next(&iter->hbi);
551}
552
553
554void bdrv_set_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap,
555 int64_t cur_sector, int64_t nr_sectors)
556{
557 assert(bdrv_dirty_bitmap_enabled(bitmap));
558 assert(!bdrv_dirty_bitmap_readonly(bitmap));
559 hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
560}
561
562void bdrv_set_dirty_bitmap(BdrvDirtyBitmap *bitmap,
563 int64_t cur_sector, int64_t nr_sectors)
564{
565 bdrv_dirty_bitmap_lock(bitmap);
566 bdrv_set_dirty_bitmap_locked(bitmap, cur_sector, nr_sectors);
567 bdrv_dirty_bitmap_unlock(bitmap);
568}
569
570
571void bdrv_reset_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap,
572 int64_t cur_sector, int64_t nr_sectors)
573{
574 assert(bdrv_dirty_bitmap_enabled(bitmap));
575 assert(!bdrv_dirty_bitmap_readonly(bitmap));
576 hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);
577}
578
579void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap *bitmap,
580 int64_t cur_sector, int64_t nr_sectors)
581{
582 bdrv_dirty_bitmap_lock(bitmap);
583 bdrv_reset_dirty_bitmap_locked(bitmap, cur_sector, nr_sectors);
584 bdrv_dirty_bitmap_unlock(bitmap);
585}
586
587void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap **out)
588{
589 assert(bdrv_dirty_bitmap_enabled(bitmap));
590 assert(!bdrv_dirty_bitmap_readonly(bitmap));
591 bdrv_dirty_bitmap_lock(bitmap);
592 if (!out) {
593 hbitmap_reset_all(bitmap->bitmap);
594 } else {
595 HBitmap *backup = bitmap->bitmap;
596 bitmap->bitmap = hbitmap_alloc(bitmap->size,
597 hbitmap_granularity(backup));
598 *out = backup;
599 }
600 bdrv_dirty_bitmap_unlock(bitmap);
601}
602
603void bdrv_undo_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap *in)
604{
605 HBitmap *tmp = bitmap->bitmap;
606 assert(bdrv_dirty_bitmap_enabled(bitmap));
607 assert(!bdrv_dirty_bitmap_readonly(bitmap));
608 bitmap->bitmap = in;
609 hbitmap_free(tmp);
610}
611
612uint64_t bdrv_dirty_bitmap_serialization_size(const BdrvDirtyBitmap *bitmap,
613 uint64_t start, uint64_t count)
614{
615 return hbitmap_serialization_size(bitmap->bitmap, start, count);
616}
617
618uint64_t bdrv_dirty_bitmap_serialization_align(const BdrvDirtyBitmap *bitmap)
619{
620 return hbitmap_serialization_granularity(bitmap->bitmap);
621}
622
623void bdrv_dirty_bitmap_serialize_part(const BdrvDirtyBitmap *bitmap,
624 uint8_t *buf, uint64_t start,
625 uint64_t count)
626{
627 hbitmap_serialize_part(bitmap->bitmap, buf, start, count);
628}
629
630void bdrv_dirty_bitmap_deserialize_part(BdrvDirtyBitmap *bitmap,
631 uint8_t *buf, uint64_t start,
632 uint64_t count, bool finish)
633{
634 hbitmap_deserialize_part(bitmap->bitmap, buf, start, count, finish);
635}
636
637void bdrv_dirty_bitmap_deserialize_zeroes(BdrvDirtyBitmap *bitmap,
638 uint64_t start, uint64_t count,
639 bool finish)
640{
641 hbitmap_deserialize_zeroes(bitmap->bitmap, start, count, finish);
642}
643
644void bdrv_dirty_bitmap_deserialize_ones(BdrvDirtyBitmap *bitmap,
645 uint64_t start, uint64_t count,
646 bool finish)
647{
648 hbitmap_deserialize_ones(bitmap->bitmap, start, count, finish);
649}
650
651void bdrv_dirty_bitmap_deserialize_finish(BdrvDirtyBitmap *bitmap)
652{
653 hbitmap_deserialize_finish(bitmap->bitmap);
654}
655
656void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector,
657 int64_t nr_sectors)
658{
659 BdrvDirtyBitmap *bitmap;
660
661 if (QLIST_EMPTY(&bs->dirty_bitmaps)) {
662 return;
663 }
664
665 bdrv_dirty_bitmaps_lock(bs);
666 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
667 if (!bdrv_dirty_bitmap_enabled(bitmap)) {
668 continue;
669 }
670 assert(!bdrv_dirty_bitmap_readonly(bitmap));
671 hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
672 }
673 bdrv_dirty_bitmaps_unlock(bs);
674}
675
676
677
678
679void bdrv_set_dirty_iter(BdrvDirtyBitmapIter *iter, int64_t sector_num)
680{
681 hbitmap_iter_init(&iter->hbi, iter->hbi.hb, sector_num);
682}
683
684int64_t bdrv_get_dirty_count(BdrvDirtyBitmap *bitmap)
685{
686 return hbitmap_count(bitmap->bitmap);
687}
688
689int64_t bdrv_get_meta_dirty_count(BdrvDirtyBitmap *bitmap)
690{
691 return hbitmap_count(bitmap->meta);
692}
693
694bool bdrv_dirty_bitmap_readonly(const BdrvDirtyBitmap *bitmap)
695{
696 return bitmap->readonly;
697}
698
699
700void bdrv_dirty_bitmap_set_readonly(BdrvDirtyBitmap *bitmap, bool value)
701{
702 qemu_mutex_lock(bitmap->mutex);
703 bitmap->readonly = value;
704 qemu_mutex_unlock(bitmap->mutex);
705}
706
707bool bdrv_has_readonly_bitmaps(BlockDriverState *bs)
708{
709 BdrvDirtyBitmap *bm;
710 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
711 if (bm->readonly) {
712 return true;
713 }
714 }
715
716 return false;
717}
718
719
720void bdrv_dirty_bitmap_set_autoload(BdrvDirtyBitmap *bitmap, bool autoload)
721{
722 qemu_mutex_lock(bitmap->mutex);
723 bitmap->autoload = autoload;
724 qemu_mutex_unlock(bitmap->mutex);
725}
726
727bool bdrv_dirty_bitmap_get_autoload(const BdrvDirtyBitmap *bitmap)
728{
729 return bitmap->autoload;
730}
731
732
733void bdrv_dirty_bitmap_set_persistance(BdrvDirtyBitmap *bitmap, bool persistent)
734{
735 qemu_mutex_lock(bitmap->mutex);
736 bitmap->persistent = persistent;
737 qemu_mutex_unlock(bitmap->mutex);
738}
739
740bool bdrv_dirty_bitmap_get_persistance(BdrvDirtyBitmap *bitmap)
741{
742 return bitmap->persistent;
743}
744
745bool bdrv_has_changed_persistent_bitmaps(BlockDriverState *bs)
746{
747 BdrvDirtyBitmap *bm;
748 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
749 if (bm->persistent && !bm->readonly) {
750 return true;
751 }
752 }
753
754 return false;
755}
756
757BdrvDirtyBitmap *bdrv_dirty_bitmap_next(BlockDriverState *bs,
758 BdrvDirtyBitmap *bitmap)
759{
760 return bitmap == NULL ? QLIST_FIRST(&bs->dirty_bitmaps) :
761 QLIST_NEXT(bitmap, list);
762}
763
764char *bdrv_dirty_bitmap_sha256(const BdrvDirtyBitmap *bitmap, Error **errp)
765{
766 return hbitmap_sha256(bitmap->bitmap, errp);
767}
768