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 HBitmap *bitmap;
41 HBitmap *meta;
42 BdrvDirtyBitmap *successor;
43 char *name;
44 int64_t size;
45 bool disabled;
46 int active_iterators;
47 QLIST_ENTRY(BdrvDirtyBitmap) list;
48};
49
50struct BdrvDirtyBitmapIter {
51 HBitmapIter hbi;
52 BdrvDirtyBitmap *bitmap;
53};
54
55BdrvDirtyBitmap *bdrv_find_dirty_bitmap(BlockDriverState *bs, const char *name)
56{
57 BdrvDirtyBitmap *bm;
58
59 assert(name);
60 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
61 if (bm->name && !strcmp(name, bm->name)) {
62 return bm;
63 }
64 }
65 return NULL;
66}
67
68void bdrv_dirty_bitmap_make_anon(BdrvDirtyBitmap *bitmap)
69{
70 assert(!bdrv_dirty_bitmap_frozen(bitmap));
71 g_free(bitmap->name);
72 bitmap->name = NULL;
73}
74
75BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs,
76 uint32_t granularity,
77 const char *name,
78 Error **errp)
79{
80 int64_t bitmap_size;
81 BdrvDirtyBitmap *bitmap;
82 uint32_t sector_granularity;
83
84 assert((granularity & (granularity - 1)) == 0);
85
86 if (name && bdrv_find_dirty_bitmap(bs, name)) {
87 error_setg(errp, "Bitmap already exists: %s", name);
88 return NULL;
89 }
90 sector_granularity = granularity >> BDRV_SECTOR_BITS;
91 assert(sector_granularity);
92 bitmap_size = bdrv_nb_sectors(bs);
93 if (bitmap_size < 0) {
94 error_setg_errno(errp, -bitmap_size, "could not get length of device");
95 errno = -bitmap_size;
96 return NULL;
97 }
98 bitmap = g_new0(BdrvDirtyBitmap, 1);
99 bitmap->bitmap = hbitmap_alloc(bitmap_size, ctz32(sector_granularity));
100 bitmap->size = bitmap_size;
101 bitmap->name = g_strdup(name);
102 bitmap->disabled = false;
103 QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list);
104 return bitmap;
105}
106
107
108
109
110
111
112
113
114
115
116
117
118void bdrv_create_meta_dirty_bitmap(BdrvDirtyBitmap *bitmap,
119 int chunk_size)
120{
121 assert(!bitmap->meta);
122 bitmap->meta = hbitmap_create_meta(bitmap->bitmap,
123 chunk_size * BITS_PER_BYTE);
124}
125
126void bdrv_release_meta_dirty_bitmap(BdrvDirtyBitmap *bitmap)
127{
128 assert(bitmap->meta);
129 hbitmap_free_meta(bitmap->bitmap);
130 bitmap->meta = NULL;
131}
132
133int bdrv_dirty_bitmap_get_meta(BlockDriverState *bs,
134 BdrvDirtyBitmap *bitmap, int64_t sector,
135 int nb_sectors)
136{
137 uint64_t i;
138 int sectors_per_bit = 1 << hbitmap_granularity(bitmap->meta);
139
140
141
142 for (i = sector; i < sector + nb_sectors; i += sectors_per_bit) {
143 if (hbitmap_get(bitmap->meta, i)) {
144 return true;
145 }
146 }
147 return false;
148}
149
150void bdrv_dirty_bitmap_reset_meta(BlockDriverState *bs,
151 BdrvDirtyBitmap *bitmap, int64_t sector,
152 int nb_sectors)
153{
154 hbitmap_reset(bitmap->meta, sector, nb_sectors);
155}
156
157int64_t bdrv_dirty_bitmap_size(const BdrvDirtyBitmap *bitmap)
158{
159 return bitmap->size;
160}
161
162const char *bdrv_dirty_bitmap_name(const BdrvDirtyBitmap *bitmap)
163{
164 return bitmap->name;
165}
166
167bool bdrv_dirty_bitmap_frozen(BdrvDirtyBitmap *bitmap)
168{
169 return bitmap->successor;
170}
171
172bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap *bitmap)
173{
174 return !(bitmap->disabled || bitmap->successor);
175}
176
177DirtyBitmapStatus bdrv_dirty_bitmap_status(BdrvDirtyBitmap *bitmap)
178{
179 if (bdrv_dirty_bitmap_frozen(bitmap)) {
180 return DIRTY_BITMAP_STATUS_FROZEN;
181 } else if (!bdrv_dirty_bitmap_enabled(bitmap)) {
182 return DIRTY_BITMAP_STATUS_DISABLED;
183 } else {
184 return DIRTY_BITMAP_STATUS_ACTIVE;
185 }
186}
187
188
189
190
191
192int bdrv_dirty_bitmap_create_successor(BlockDriverState *bs,
193 BdrvDirtyBitmap *bitmap, Error **errp)
194{
195 uint64_t granularity;
196 BdrvDirtyBitmap *child;
197
198 if (bdrv_dirty_bitmap_frozen(bitmap)) {
199 error_setg(errp, "Cannot create a successor for a bitmap that is "
200 "currently frozen");
201 return -1;
202 }
203 assert(!bitmap->successor);
204
205
206 granularity = bdrv_dirty_bitmap_granularity(bitmap);
207 child = bdrv_create_dirty_bitmap(bs, granularity, NULL, errp);
208 if (!child) {
209 return -1;
210 }
211
212
213 child->disabled = bitmap->disabled;
214
215
216 bitmap->successor = child;
217 return 0;
218}
219
220
221
222
223
224BdrvDirtyBitmap *bdrv_dirty_bitmap_abdicate(BlockDriverState *bs,
225 BdrvDirtyBitmap *bitmap,
226 Error **errp)
227{
228 char *name;
229 BdrvDirtyBitmap *successor = bitmap->successor;
230
231 if (successor == NULL) {
232 error_setg(errp, "Cannot relinquish control if "
233 "there's no successor present");
234 return NULL;
235 }
236
237 name = bitmap->name;
238 bitmap->name = NULL;
239 successor->name = name;
240 bitmap->successor = NULL;
241 bdrv_release_dirty_bitmap(bs, bitmap);
242
243 return successor;
244}
245
246
247
248
249
250
251BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap(BlockDriverState *bs,
252 BdrvDirtyBitmap *parent,
253 Error **errp)
254{
255 BdrvDirtyBitmap *successor = parent->successor;
256
257 if (!successor) {
258 error_setg(errp, "Cannot reclaim a successor when none is present");
259 return NULL;
260 }
261
262 if (!hbitmap_merge(parent->bitmap, successor->bitmap)) {
263 error_setg(errp, "Merging of parent and successor bitmap failed");
264 return NULL;
265 }
266 bdrv_release_dirty_bitmap(bs, successor);
267 parent->successor = NULL;
268
269 return parent;
270}
271
272
273
274
275void bdrv_dirty_bitmap_truncate(BlockDriverState *bs)
276{
277 BdrvDirtyBitmap *bitmap;
278 uint64_t size = bdrv_nb_sectors(bs);
279
280 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
281 assert(!bdrv_dirty_bitmap_frozen(bitmap));
282 assert(!bitmap->active_iterators);
283 hbitmap_truncate(bitmap->bitmap, size);
284 bitmap->size = size;
285 }
286}
287
288static void bdrv_do_release_matching_dirty_bitmap(BlockDriverState *bs,
289 BdrvDirtyBitmap *bitmap,
290 bool only_named)
291{
292 BdrvDirtyBitmap *bm, *next;
293 QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) {
294 if ((!bitmap || bm == bitmap) && (!only_named || bm->name)) {
295 assert(!bm->active_iterators);
296 assert(!bdrv_dirty_bitmap_frozen(bm));
297 assert(!bm->meta);
298 QLIST_REMOVE(bm, list);
299 hbitmap_free(bm->bitmap);
300 g_free(bm->name);
301 g_free(bm);
302
303 if (bitmap) {
304 return;
305 }
306 }
307 }
308 if (bitmap) {
309 abort();
310 }
311}
312
313void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
314{
315 bdrv_do_release_matching_dirty_bitmap(bs, bitmap, false);
316}
317
318
319
320
321
322void bdrv_release_named_dirty_bitmaps(BlockDriverState *bs)
323{
324 bdrv_do_release_matching_dirty_bitmap(bs, NULL, true);
325}
326
327void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
328{
329 assert(!bdrv_dirty_bitmap_frozen(bitmap));
330 bitmap->disabled = true;
331}
332
333void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
334{
335 assert(!bdrv_dirty_bitmap_frozen(bitmap));
336 bitmap->disabled = false;
337}
338
339BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs)
340{
341 BdrvDirtyBitmap *bm;
342 BlockDirtyInfoList *list = NULL;
343 BlockDirtyInfoList **plist = &list;
344
345 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
346 BlockDirtyInfo *info = g_new0(BlockDirtyInfo, 1);
347 BlockDirtyInfoList *entry = g_new0(BlockDirtyInfoList, 1);
348 info->count = bdrv_get_dirty_count(bm);
349 info->granularity = bdrv_dirty_bitmap_granularity(bm);
350 info->has_name = !!bm->name;
351 info->name = g_strdup(bm->name);
352 info->status = bdrv_dirty_bitmap_status(bm);
353 entry->value = info;
354 *plist = entry;
355 plist = &entry->next;
356 }
357
358 return list;
359}
360
361int bdrv_get_dirty(BlockDriverState *bs, BdrvDirtyBitmap *bitmap,
362 int64_t sector)
363{
364 if (bitmap) {
365 return hbitmap_get(bitmap->bitmap, sector);
366 } else {
367 return 0;
368 }
369}
370
371
372
373
374
375
376uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState *bs)
377{
378 BlockDriverInfo bdi;
379 uint32_t granularity;
380
381 if (bdrv_get_info(bs, &bdi) >= 0 && bdi.cluster_size > 0) {
382 granularity = MAX(4096, bdi.cluster_size);
383 granularity = MIN(65536, granularity);
384 } else {
385 granularity = 65536;
386 }
387
388 return granularity;
389}
390
391uint32_t bdrv_dirty_bitmap_granularity(BdrvDirtyBitmap *bitmap)
392{
393 return BDRV_SECTOR_SIZE << hbitmap_granularity(bitmap->bitmap);
394}
395
396uint32_t bdrv_dirty_bitmap_meta_granularity(BdrvDirtyBitmap *bitmap)
397{
398 return BDRV_SECTOR_SIZE << hbitmap_granularity(bitmap->meta);
399}
400
401BdrvDirtyBitmapIter *bdrv_dirty_iter_new(BdrvDirtyBitmap *bitmap,
402 uint64_t first_sector)
403{
404 BdrvDirtyBitmapIter *iter = g_new(BdrvDirtyBitmapIter, 1);
405 hbitmap_iter_init(&iter->hbi, bitmap->bitmap, first_sector);
406 iter->bitmap = bitmap;
407 bitmap->active_iterators++;
408 return iter;
409}
410
411BdrvDirtyBitmapIter *bdrv_dirty_meta_iter_new(BdrvDirtyBitmap *bitmap)
412{
413 BdrvDirtyBitmapIter *iter = g_new(BdrvDirtyBitmapIter, 1);
414 hbitmap_iter_init(&iter->hbi, bitmap->meta, 0);
415 iter->bitmap = bitmap;
416 bitmap->active_iterators++;
417 return iter;
418}
419
420void bdrv_dirty_iter_free(BdrvDirtyBitmapIter *iter)
421{
422 if (!iter) {
423 return;
424 }
425 assert(iter->bitmap->active_iterators > 0);
426 iter->bitmap->active_iterators--;
427 g_free(iter);
428}
429
430int64_t bdrv_dirty_iter_next(BdrvDirtyBitmapIter *iter)
431{
432 return hbitmap_iter_next(&iter->hbi);
433}
434
435void bdrv_set_dirty_bitmap(BdrvDirtyBitmap *bitmap,
436 int64_t cur_sector, int64_t nr_sectors)
437{
438 assert(bdrv_dirty_bitmap_enabled(bitmap));
439 hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
440}
441
442void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap *bitmap,
443 int64_t cur_sector, int64_t nr_sectors)
444{
445 assert(bdrv_dirty_bitmap_enabled(bitmap));
446 hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);
447}
448
449void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap **out)
450{
451 assert(bdrv_dirty_bitmap_enabled(bitmap));
452 if (!out) {
453 hbitmap_reset_all(bitmap->bitmap);
454 } else {
455 HBitmap *backup = bitmap->bitmap;
456 bitmap->bitmap = hbitmap_alloc(bitmap->size,
457 hbitmap_granularity(backup));
458 *out = backup;
459 }
460}
461
462void bdrv_undo_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap *in)
463{
464 HBitmap *tmp = bitmap->bitmap;
465 assert(bdrv_dirty_bitmap_enabled(bitmap));
466 bitmap->bitmap = in;
467 hbitmap_free(tmp);
468}
469
470uint64_t bdrv_dirty_bitmap_serialization_size(const BdrvDirtyBitmap *bitmap,
471 uint64_t start, uint64_t count)
472{
473 return hbitmap_serialization_size(bitmap->bitmap, start, count);
474}
475
476uint64_t bdrv_dirty_bitmap_serialization_align(const BdrvDirtyBitmap *bitmap)
477{
478 return hbitmap_serialization_granularity(bitmap->bitmap);
479}
480
481void bdrv_dirty_bitmap_serialize_part(const BdrvDirtyBitmap *bitmap,
482 uint8_t *buf, uint64_t start,
483 uint64_t count)
484{
485 hbitmap_serialize_part(bitmap->bitmap, buf, start, count);
486}
487
488void bdrv_dirty_bitmap_deserialize_part(BdrvDirtyBitmap *bitmap,
489 uint8_t *buf, uint64_t start,
490 uint64_t count, bool finish)
491{
492 hbitmap_deserialize_part(bitmap->bitmap, buf, start, count, finish);
493}
494
495void bdrv_dirty_bitmap_deserialize_zeroes(BdrvDirtyBitmap *bitmap,
496 uint64_t start, uint64_t count,
497 bool finish)
498{
499 hbitmap_deserialize_zeroes(bitmap->bitmap, start, count, finish);
500}
501
502void bdrv_dirty_bitmap_deserialize_finish(BdrvDirtyBitmap *bitmap)
503{
504 hbitmap_deserialize_finish(bitmap->bitmap);
505}
506
507void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector,
508 int64_t nr_sectors)
509{
510 BdrvDirtyBitmap *bitmap;
511 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
512 if (!bdrv_dirty_bitmap_enabled(bitmap)) {
513 continue;
514 }
515 hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
516 }
517}
518
519
520
521
522void bdrv_set_dirty_iter(BdrvDirtyBitmapIter *iter, int64_t sector_num)
523{
524 hbitmap_iter_init(&iter->hbi, iter->hbi.hb, sector_num);
525}
526
527int64_t bdrv_get_dirty_count(BdrvDirtyBitmap *bitmap)
528{
529 return hbitmap_count(bitmap->bitmap);
530}
531
532int64_t bdrv_get_meta_dirty_count(BdrvDirtyBitmap *bitmap)
533{
534 return hbitmap_count(bitmap->meta);
535}
536