]>
Commit | Line | Data |
---|---|---|
ebab2259 FZ |
1 | /* |
2 | * Block Dirty Bitmap | |
3 | * | |
4 | * Copyright (c) 2016 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" | |
da34e65c | 25 | #include "qapi/error.h" |
ebab2259 FZ |
26 | #include "qemu-common.h" |
27 | #include "trace.h" | |
28 | #include "block/block_int.h" | |
29 | #include "block/blockjob.h" | |
30 | ||
31 | /** | |
32 | * A BdrvDirtyBitmap can be in three possible states: | |
33 | * (1) successor is NULL and disabled is false: full r/w mode | |
34 | * (2) successor is NULL and disabled is true: read only mode ("disabled") | |
35 | * (3) successor is set: frozen mode. | |
36 | * A frozen bitmap cannot be renamed, deleted, anonymized, cleared, set, | |
37 | * or enabled. A frozen bitmap can only abdicate() or reclaim(). | |
38 | */ | |
39 | struct BdrvDirtyBitmap { | |
b64bd51e | 40 | QemuMutex *mutex; |
ebab2259 | 41 | HBitmap *bitmap; /* Dirty sector bitmap implementation */ |
fb933437 | 42 | HBitmap *meta; /* Meta dirty bitmap */ |
ebab2259 FZ |
43 | BdrvDirtyBitmap *successor; /* Anonymous child; implies frozen status */ |
44 | char *name; /* Optional non-empty unique ID */ | |
45 | int64_t size; /* Size of the bitmap (Number of sectors) */ | |
8bfc932e VSO |
46 | bool disabled; /* Bitmap is disabled. It ignores all writes to |
47 | the device */ | |
dc162c8e | 48 | int active_iterators; /* How many iterators are active */ |
ebab2259 FZ |
49 | QLIST_ENTRY(BdrvDirtyBitmap) list; |
50 | }; | |
51 | ||
dc162c8e FZ |
52 | struct BdrvDirtyBitmapIter { |
53 | HBitmapIter hbi; | |
54 | BdrvDirtyBitmap *bitmap; | |
55 | }; | |
56 | ||
2119882c PB |
57 | static inline void bdrv_dirty_bitmaps_lock(BlockDriverState *bs) |
58 | { | |
59 | qemu_mutex_lock(&bs->dirty_bitmap_mutex); | |
60 | } | |
61 | ||
62 | static inline void bdrv_dirty_bitmaps_unlock(BlockDriverState *bs) | |
63 | { | |
64 | qemu_mutex_unlock(&bs->dirty_bitmap_mutex); | |
65 | } | |
66 | ||
b64bd51e PB |
67 | void bdrv_dirty_bitmap_lock(BdrvDirtyBitmap *bitmap) |
68 | { | |
69 | qemu_mutex_lock(bitmap->mutex); | |
70 | } | |
71 | ||
72 | void bdrv_dirty_bitmap_unlock(BdrvDirtyBitmap *bitmap) | |
73 | { | |
74 | qemu_mutex_unlock(bitmap->mutex); | |
75 | } | |
76 | ||
2119882c | 77 | /* Called with BQL or dirty_bitmap lock taken. */ |
ebab2259 FZ |
78 | BdrvDirtyBitmap *bdrv_find_dirty_bitmap(BlockDriverState *bs, const char *name) |
79 | { | |
80 | BdrvDirtyBitmap *bm; | |
81 | ||
82 | assert(name); | |
83 | QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) { | |
84 | if (bm->name && !strcmp(name, bm->name)) { | |
85 | return bm; | |
86 | } | |
87 | } | |
88 | return NULL; | |
89 | } | |
90 | ||
2119882c | 91 | /* Called with BQL taken. */ |
ebab2259 FZ |
92 | void bdrv_dirty_bitmap_make_anon(BdrvDirtyBitmap *bitmap) |
93 | { | |
94 | assert(!bdrv_dirty_bitmap_frozen(bitmap)); | |
95 | g_free(bitmap->name); | |
96 | bitmap->name = NULL; | |
97 | } | |
98 | ||
2119882c | 99 | /* Called with BQL taken. */ |
ebab2259 FZ |
100 | BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs, |
101 | uint32_t granularity, | |
102 | const char *name, | |
103 | Error **errp) | |
104 | { | |
105 | int64_t bitmap_size; | |
106 | BdrvDirtyBitmap *bitmap; | |
107 | uint32_t sector_granularity; | |
108 | ||
109 | assert((granularity & (granularity - 1)) == 0); | |
110 | ||
111 | if (name && bdrv_find_dirty_bitmap(bs, name)) { | |
112 | error_setg(errp, "Bitmap already exists: %s", name); | |
113 | return NULL; | |
114 | } | |
115 | sector_granularity = granularity >> BDRV_SECTOR_BITS; | |
116 | assert(sector_granularity); | |
117 | bitmap_size = bdrv_nb_sectors(bs); | |
118 | if (bitmap_size < 0) { | |
119 | error_setg_errno(errp, -bitmap_size, "could not get length of device"); | |
120 | errno = -bitmap_size; | |
121 | return NULL; | |
122 | } | |
123 | bitmap = g_new0(BdrvDirtyBitmap, 1); | |
b64bd51e | 124 | bitmap->mutex = &bs->dirty_bitmap_mutex; |
ebab2259 FZ |
125 | bitmap->bitmap = hbitmap_alloc(bitmap_size, ctz32(sector_granularity)); |
126 | bitmap->size = bitmap_size; | |
127 | bitmap->name = g_strdup(name); | |
128 | bitmap->disabled = false; | |
2119882c | 129 | bdrv_dirty_bitmaps_lock(bs); |
ebab2259 | 130 | QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list); |
2119882c | 131 | bdrv_dirty_bitmaps_unlock(bs); |
ebab2259 FZ |
132 | return bitmap; |
133 | } | |
134 | ||
fb933437 FZ |
135 | /* bdrv_create_meta_dirty_bitmap |
136 | * | |
137 | * Create a meta dirty bitmap that tracks the changes of bits in @bitmap. I.e. | |
138 | * when a dirty status bit in @bitmap is changed (either from reset to set or | |
139 | * the other way around), its respective meta dirty bitmap bit will be marked | |
140 | * dirty as well. | |
141 | * | |
142 | * @bitmap: the block dirty bitmap for which to create a meta dirty bitmap. | |
143 | * @chunk_size: how many bytes of bitmap data does each bit in the meta bitmap | |
144 | * track. | |
145 | */ | |
146 | void bdrv_create_meta_dirty_bitmap(BdrvDirtyBitmap *bitmap, | |
147 | int chunk_size) | |
148 | { | |
149 | assert(!bitmap->meta); | |
b64bd51e | 150 | qemu_mutex_lock(bitmap->mutex); |
fb933437 FZ |
151 | bitmap->meta = hbitmap_create_meta(bitmap->bitmap, |
152 | chunk_size * BITS_PER_BYTE); | |
b64bd51e | 153 | qemu_mutex_unlock(bitmap->mutex); |
fb933437 FZ |
154 | } |
155 | ||
156 | void bdrv_release_meta_dirty_bitmap(BdrvDirtyBitmap *bitmap) | |
157 | { | |
158 | assert(bitmap->meta); | |
b64bd51e | 159 | qemu_mutex_lock(bitmap->mutex); |
fb933437 FZ |
160 | hbitmap_free_meta(bitmap->bitmap); |
161 | bitmap->meta = NULL; | |
b64bd51e | 162 | qemu_mutex_unlock(bitmap->mutex); |
fb933437 FZ |
163 | } |
164 | ||
b64bd51e PB |
165 | int bdrv_dirty_bitmap_get_meta_locked(BlockDriverState *bs, |
166 | BdrvDirtyBitmap *bitmap, int64_t sector, | |
167 | int nb_sectors) | |
fb933437 FZ |
168 | { |
169 | uint64_t i; | |
170 | int sectors_per_bit = 1 << hbitmap_granularity(bitmap->meta); | |
171 | ||
172 | /* To optimize: we can make hbitmap to internally check the range in a | |
173 | * coarse level, or at least do it word by word. */ | |
174 | for (i = sector; i < sector + nb_sectors; i += sectors_per_bit) { | |
175 | if (hbitmap_get(bitmap->meta, i)) { | |
176 | return true; | |
177 | } | |
178 | } | |
179 | return false; | |
180 | } | |
181 | ||
b64bd51e PB |
182 | int bdrv_dirty_bitmap_get_meta(BlockDriverState *bs, |
183 | BdrvDirtyBitmap *bitmap, int64_t sector, | |
184 | int nb_sectors) | |
185 | { | |
186 | bool dirty; | |
187 | ||
188 | qemu_mutex_lock(bitmap->mutex); | |
189 | dirty = bdrv_dirty_bitmap_get_meta_locked(bs, bitmap, sector, nb_sectors); | |
190 | qemu_mutex_unlock(bitmap->mutex); | |
191 | ||
192 | return dirty; | |
193 | } | |
194 | ||
fb933437 FZ |
195 | void bdrv_dirty_bitmap_reset_meta(BlockDriverState *bs, |
196 | BdrvDirtyBitmap *bitmap, int64_t sector, | |
197 | int nb_sectors) | |
198 | { | |
b64bd51e | 199 | qemu_mutex_lock(bitmap->mutex); |
fb933437 | 200 | hbitmap_reset(bitmap->meta, sector, nb_sectors); |
b64bd51e | 201 | qemu_mutex_unlock(bitmap->mutex); |
fb933437 FZ |
202 | } |
203 | ||
15891fac FZ |
204 | int64_t bdrv_dirty_bitmap_size(const BdrvDirtyBitmap *bitmap) |
205 | { | |
206 | return bitmap->size; | |
207 | } | |
208 | ||
209 | const char *bdrv_dirty_bitmap_name(const BdrvDirtyBitmap *bitmap) | |
210 | { | |
211 | return bitmap->name; | |
212 | } | |
213 | ||
2119882c | 214 | /* Called with BQL taken. */ |
ebab2259 FZ |
215 | bool bdrv_dirty_bitmap_frozen(BdrvDirtyBitmap *bitmap) |
216 | { | |
217 | return bitmap->successor; | |
218 | } | |
219 | ||
2119882c | 220 | /* Called with BQL taken. */ |
ebab2259 FZ |
221 | bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap *bitmap) |
222 | { | |
223 | return !(bitmap->disabled || bitmap->successor); | |
224 | } | |
225 | ||
2119882c | 226 | /* Called with BQL taken. */ |
ebab2259 FZ |
227 | DirtyBitmapStatus bdrv_dirty_bitmap_status(BdrvDirtyBitmap *bitmap) |
228 | { | |
229 | if (bdrv_dirty_bitmap_frozen(bitmap)) { | |
230 | return DIRTY_BITMAP_STATUS_FROZEN; | |
231 | } else if (!bdrv_dirty_bitmap_enabled(bitmap)) { | |
232 | return DIRTY_BITMAP_STATUS_DISABLED; | |
233 | } else { | |
234 | return DIRTY_BITMAP_STATUS_ACTIVE; | |
235 | } | |
236 | } | |
237 | ||
238 | /** | |
239 | * Create a successor bitmap destined to replace this bitmap after an operation. | |
240 | * Requires that the bitmap is not frozen and has no successor. | |
2119882c | 241 | * Called with BQL taken. |
ebab2259 FZ |
242 | */ |
243 | int bdrv_dirty_bitmap_create_successor(BlockDriverState *bs, | |
244 | BdrvDirtyBitmap *bitmap, Error **errp) | |
245 | { | |
246 | uint64_t granularity; | |
247 | BdrvDirtyBitmap *child; | |
248 | ||
249 | if (bdrv_dirty_bitmap_frozen(bitmap)) { | |
250 | error_setg(errp, "Cannot create a successor for a bitmap that is " | |
251 | "currently frozen"); | |
252 | return -1; | |
253 | } | |
254 | assert(!bitmap->successor); | |
255 | ||
256 | /* Create an anonymous successor */ | |
257 | granularity = bdrv_dirty_bitmap_granularity(bitmap); | |
258 | child = bdrv_create_dirty_bitmap(bs, granularity, NULL, errp); | |
259 | if (!child) { | |
260 | return -1; | |
261 | } | |
262 | ||
263 | /* Successor will be on or off based on our current state. */ | |
264 | child->disabled = bitmap->disabled; | |
265 | ||
266 | /* Install the successor and freeze the parent */ | |
267 | bitmap->successor = child; | |
268 | return 0; | |
269 | } | |
270 | ||
271 | /** | |
272 | * For a bitmap with a successor, yield our name to the successor, | |
273 | * delete the old bitmap, and return a handle to the new bitmap. | |
2119882c | 274 | * Called with BQL taken. |
ebab2259 FZ |
275 | */ |
276 | BdrvDirtyBitmap *bdrv_dirty_bitmap_abdicate(BlockDriverState *bs, | |
277 | BdrvDirtyBitmap *bitmap, | |
278 | Error **errp) | |
279 | { | |
280 | char *name; | |
281 | BdrvDirtyBitmap *successor = bitmap->successor; | |
282 | ||
283 | if (successor == NULL) { | |
284 | error_setg(errp, "Cannot relinquish control if " | |
285 | "there's no successor present"); | |
286 | return NULL; | |
287 | } | |
288 | ||
289 | name = bitmap->name; | |
290 | bitmap->name = NULL; | |
291 | successor->name = name; | |
292 | bitmap->successor = NULL; | |
293 | bdrv_release_dirty_bitmap(bs, bitmap); | |
294 | ||
295 | return successor; | |
296 | } | |
297 | ||
298 | /** | |
299 | * In cases of failure where we can no longer safely delete the parent, | |
300 | * we may wish to re-join the parent and child/successor. | |
301 | * The merged parent will be un-frozen, but not explicitly re-enabled. | |
2119882c | 302 | * Called with BQL taken. |
ebab2259 FZ |
303 | */ |
304 | BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap(BlockDriverState *bs, | |
305 | BdrvDirtyBitmap *parent, | |
306 | Error **errp) | |
307 | { | |
308 | BdrvDirtyBitmap *successor = parent->successor; | |
309 | ||
310 | if (!successor) { | |
311 | error_setg(errp, "Cannot reclaim a successor when none is present"); | |
312 | return NULL; | |
313 | } | |
314 | ||
315 | if (!hbitmap_merge(parent->bitmap, successor->bitmap)) { | |
316 | error_setg(errp, "Merging of parent and successor bitmap failed"); | |
317 | return NULL; | |
318 | } | |
319 | bdrv_release_dirty_bitmap(bs, successor); | |
320 | parent->successor = NULL; | |
321 | ||
322 | return parent; | |
323 | } | |
324 | ||
325 | /** | |
326 | * Truncates _all_ bitmaps attached to a BDS. | |
2119882c | 327 | * Called with BQL taken. |
ebab2259 FZ |
328 | */ |
329 | void bdrv_dirty_bitmap_truncate(BlockDriverState *bs) | |
330 | { | |
331 | BdrvDirtyBitmap *bitmap; | |
332 | uint64_t size = bdrv_nb_sectors(bs); | |
333 | ||
2119882c | 334 | bdrv_dirty_bitmaps_lock(bs); |
ebab2259 FZ |
335 | QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) { |
336 | assert(!bdrv_dirty_bitmap_frozen(bitmap)); | |
dc162c8e | 337 | assert(!bitmap->active_iterators); |
ebab2259 FZ |
338 | hbitmap_truncate(bitmap->bitmap, size); |
339 | bitmap->size = size; | |
340 | } | |
2119882c | 341 | bdrv_dirty_bitmaps_unlock(bs); |
ebab2259 FZ |
342 | } |
343 | ||
2119882c | 344 | /* Called with BQL taken. */ |
ebab2259 FZ |
345 | static void bdrv_do_release_matching_dirty_bitmap(BlockDriverState *bs, |
346 | BdrvDirtyBitmap *bitmap, | |
347 | bool only_named) | |
348 | { | |
349 | BdrvDirtyBitmap *bm, *next; | |
2119882c | 350 | bdrv_dirty_bitmaps_lock(bs); |
ebab2259 FZ |
351 | QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) { |
352 | if ((!bitmap || bm == bitmap) && (!only_named || bm->name)) { | |
dc162c8e | 353 | assert(!bm->active_iterators); |
ebab2259 | 354 | assert(!bdrv_dirty_bitmap_frozen(bm)); |
fb933437 | 355 | assert(!bm->meta); |
ebab2259 FZ |
356 | QLIST_REMOVE(bm, list); |
357 | hbitmap_free(bm->bitmap); | |
358 | g_free(bm->name); | |
359 | g_free(bm); | |
360 | ||
361 | if (bitmap) { | |
2119882c | 362 | goto out; |
ebab2259 FZ |
363 | } |
364 | } | |
365 | } | |
7105007a FZ |
366 | if (bitmap) { |
367 | abort(); | |
368 | } | |
2119882c PB |
369 | |
370 | out: | |
371 | bdrv_dirty_bitmaps_unlock(bs); | |
ebab2259 FZ |
372 | } |
373 | ||
2119882c | 374 | /* Called with BQL taken. */ |
ebab2259 FZ |
375 | void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap) |
376 | { | |
377 | bdrv_do_release_matching_dirty_bitmap(bs, bitmap, false); | |
378 | } | |
379 | ||
380 | /** | |
381 | * Release all named dirty bitmaps attached to a BDS (for use in bdrv_close()). | |
382 | * There must not be any frozen bitmaps attached. | |
2119882c | 383 | * Called with BQL taken. |
ebab2259 FZ |
384 | */ |
385 | void bdrv_release_named_dirty_bitmaps(BlockDriverState *bs) | |
386 | { | |
387 | bdrv_do_release_matching_dirty_bitmap(bs, NULL, true); | |
388 | } | |
389 | ||
2119882c | 390 | /* Called with BQL taken. */ |
ebab2259 FZ |
391 | void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap *bitmap) |
392 | { | |
393 | assert(!bdrv_dirty_bitmap_frozen(bitmap)); | |
394 | bitmap->disabled = true; | |
395 | } | |
396 | ||
2119882c | 397 | /* Called with BQL taken. */ |
ebab2259 FZ |
398 | void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap *bitmap) |
399 | { | |
400 | assert(!bdrv_dirty_bitmap_frozen(bitmap)); | |
401 | bitmap->disabled = false; | |
402 | } | |
403 | ||
404 | BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs) | |
405 | { | |
406 | BdrvDirtyBitmap *bm; | |
407 | BlockDirtyInfoList *list = NULL; | |
408 | BlockDirtyInfoList **plist = &list; | |
409 | ||
2119882c | 410 | bdrv_dirty_bitmaps_lock(bs); |
ebab2259 FZ |
411 | QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) { |
412 | BlockDirtyInfo *info = g_new0(BlockDirtyInfo, 1); | |
413 | BlockDirtyInfoList *entry = g_new0(BlockDirtyInfoList, 1); | |
414 | info->count = bdrv_get_dirty_count(bm); | |
415 | info->granularity = bdrv_dirty_bitmap_granularity(bm); | |
416 | info->has_name = !!bm->name; | |
417 | info->name = g_strdup(bm->name); | |
418 | info->status = bdrv_dirty_bitmap_status(bm); | |
419 | entry->value = info; | |
420 | *plist = entry; | |
421 | plist = &entry->next; | |
422 | } | |
2119882c | 423 | bdrv_dirty_bitmaps_unlock(bs); |
ebab2259 FZ |
424 | |
425 | return list; | |
426 | } | |
427 | ||
b64bd51e PB |
428 | /* Called within bdrv_dirty_bitmap_lock..unlock */ |
429 | int bdrv_get_dirty_locked(BlockDriverState *bs, BdrvDirtyBitmap *bitmap, | |
430 | int64_t sector) | |
ebab2259 FZ |
431 | { |
432 | if (bitmap) { | |
433 | return hbitmap_get(bitmap->bitmap, sector); | |
434 | } else { | |
435 | return 0; | |
436 | } | |
437 | } | |
438 | ||
439 | /** | |
440 | * Chooses a default granularity based on the existing cluster size, | |
441 | * but clamped between [4K, 64K]. Defaults to 64K in the case that there | |
442 | * is no cluster size information available. | |
443 | */ | |
444 | uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState *bs) | |
445 | { | |
446 | BlockDriverInfo bdi; | |
447 | uint32_t granularity; | |
448 | ||
449 | if (bdrv_get_info(bs, &bdi) >= 0 && bdi.cluster_size > 0) { | |
450 | granularity = MAX(4096, bdi.cluster_size); | |
451 | granularity = MIN(65536, granularity); | |
452 | } else { | |
453 | granularity = 65536; | |
454 | } | |
455 | ||
456 | return granularity; | |
457 | } | |
458 | ||
ba06ff1a | 459 | uint32_t bdrv_dirty_bitmap_granularity(const BdrvDirtyBitmap *bitmap) |
ebab2259 FZ |
460 | { |
461 | return BDRV_SECTOR_SIZE << hbitmap_granularity(bitmap->bitmap); | |
462 | } | |
463 | ||
6d3f4049 FZ |
464 | uint32_t bdrv_dirty_bitmap_meta_granularity(BdrvDirtyBitmap *bitmap) |
465 | { | |
466 | return BDRV_SECTOR_SIZE << hbitmap_granularity(bitmap->meta); | |
467 | } | |
468 | ||
dc162c8e FZ |
469 | BdrvDirtyBitmapIter *bdrv_dirty_iter_new(BdrvDirtyBitmap *bitmap, |
470 | uint64_t first_sector) | |
471 | { | |
472 | BdrvDirtyBitmapIter *iter = g_new(BdrvDirtyBitmapIter, 1); | |
473 | hbitmap_iter_init(&iter->hbi, bitmap->bitmap, first_sector); | |
474 | iter->bitmap = bitmap; | |
475 | bitmap->active_iterators++; | |
476 | return iter; | |
477 | } | |
478 | ||
6d3f4049 FZ |
479 | BdrvDirtyBitmapIter *bdrv_dirty_meta_iter_new(BdrvDirtyBitmap *bitmap) |
480 | { | |
481 | BdrvDirtyBitmapIter *iter = g_new(BdrvDirtyBitmapIter, 1); | |
482 | hbitmap_iter_init(&iter->hbi, bitmap->meta, 0); | |
483 | iter->bitmap = bitmap; | |
484 | bitmap->active_iterators++; | |
485 | return iter; | |
486 | } | |
487 | ||
dc162c8e FZ |
488 | void bdrv_dirty_iter_free(BdrvDirtyBitmapIter *iter) |
489 | { | |
490 | if (!iter) { | |
491 | return; | |
492 | } | |
493 | assert(iter->bitmap->active_iterators > 0); | |
494 | iter->bitmap->active_iterators--; | |
495 | g_free(iter); | |
496 | } | |
497 | ||
498 | int64_t bdrv_dirty_iter_next(BdrvDirtyBitmapIter *iter) | |
ebab2259 | 499 | { |
dc162c8e | 500 | return hbitmap_iter_next(&iter->hbi); |
ebab2259 FZ |
501 | } |
502 | ||
b64bd51e PB |
503 | /* Called within bdrv_dirty_bitmap_lock..unlock */ |
504 | void bdrv_set_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap, | |
505 | int64_t cur_sector, int64_t nr_sectors) | |
506 | { | |
507 | assert(bdrv_dirty_bitmap_enabled(bitmap)); | |
508 | hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors); | |
509 | } | |
510 | ||
ebab2259 | 511 | void bdrv_set_dirty_bitmap(BdrvDirtyBitmap *bitmap, |
6d078599 | 512 | int64_t cur_sector, int64_t nr_sectors) |
b64bd51e PB |
513 | { |
514 | bdrv_dirty_bitmap_lock(bitmap); | |
515 | bdrv_set_dirty_bitmap_locked(bitmap, cur_sector, nr_sectors); | |
516 | bdrv_dirty_bitmap_unlock(bitmap); | |
517 | } | |
518 | ||
519 | /* Called within bdrv_dirty_bitmap_lock..unlock */ | |
520 | void bdrv_reset_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap, | |
521 | int64_t cur_sector, int64_t nr_sectors) | |
ebab2259 FZ |
522 | { |
523 | assert(bdrv_dirty_bitmap_enabled(bitmap)); | |
b64bd51e | 524 | hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors); |
ebab2259 FZ |
525 | } |
526 | ||
527 | void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap *bitmap, | |
6d078599 | 528 | int64_t cur_sector, int64_t nr_sectors) |
ebab2259 | 529 | { |
b64bd51e PB |
530 | bdrv_dirty_bitmap_lock(bitmap); |
531 | bdrv_reset_dirty_bitmap_locked(bitmap, cur_sector, nr_sectors); | |
532 | bdrv_dirty_bitmap_unlock(bitmap); | |
ebab2259 FZ |
533 | } |
534 | ||
535 | void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap **out) | |
536 | { | |
537 | assert(bdrv_dirty_bitmap_enabled(bitmap)); | |
b64bd51e | 538 | bdrv_dirty_bitmap_lock(bitmap); |
ebab2259 FZ |
539 | if (!out) { |
540 | hbitmap_reset_all(bitmap->bitmap); | |
541 | } else { | |
542 | HBitmap *backup = bitmap->bitmap; | |
543 | bitmap->bitmap = hbitmap_alloc(bitmap->size, | |
544 | hbitmap_granularity(backup)); | |
545 | *out = backup; | |
546 | } | |
b64bd51e | 547 | bdrv_dirty_bitmap_unlock(bitmap); |
ebab2259 FZ |
548 | } |
549 | ||
550 | void bdrv_undo_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap *in) | |
551 | { | |
552 | HBitmap *tmp = bitmap->bitmap; | |
553 | assert(bdrv_dirty_bitmap_enabled(bitmap)); | |
554 | bitmap->bitmap = in; | |
555 | hbitmap_free(tmp); | |
556 | } | |
557 | ||
882c36f5 VSO |
558 | uint64_t bdrv_dirty_bitmap_serialization_size(const BdrvDirtyBitmap *bitmap, |
559 | uint64_t start, uint64_t count) | |
560 | { | |
561 | return hbitmap_serialization_size(bitmap->bitmap, start, count); | |
562 | } | |
563 | ||
564 | uint64_t bdrv_dirty_bitmap_serialization_align(const BdrvDirtyBitmap *bitmap) | |
565 | { | |
566 | return hbitmap_serialization_granularity(bitmap->bitmap); | |
567 | } | |
568 | ||
569 | void bdrv_dirty_bitmap_serialize_part(const BdrvDirtyBitmap *bitmap, | |
570 | uint8_t *buf, uint64_t start, | |
571 | uint64_t count) | |
572 | { | |
573 | hbitmap_serialize_part(bitmap->bitmap, buf, start, count); | |
574 | } | |
575 | ||
576 | void bdrv_dirty_bitmap_deserialize_part(BdrvDirtyBitmap *bitmap, | |
577 | uint8_t *buf, uint64_t start, | |
578 | uint64_t count, bool finish) | |
579 | { | |
580 | hbitmap_deserialize_part(bitmap->bitmap, buf, start, count, finish); | |
581 | } | |
582 | ||
583 | void bdrv_dirty_bitmap_deserialize_zeroes(BdrvDirtyBitmap *bitmap, | |
584 | uint64_t start, uint64_t count, | |
585 | bool finish) | |
586 | { | |
587 | hbitmap_deserialize_zeroes(bitmap->bitmap, start, count, finish); | |
6bdc8b71 VSO |
588 | } |
589 | ||
590 | void bdrv_dirty_bitmap_deserialize_ones(BdrvDirtyBitmap *bitmap, | |
591 | uint64_t start, uint64_t count, | |
592 | bool finish) | |
593 | { | |
594 | hbitmap_deserialize_ones(bitmap->bitmap, start, count, finish); | |
882c36f5 VSO |
595 | } |
596 | ||
597 | void bdrv_dirty_bitmap_deserialize_finish(BdrvDirtyBitmap *bitmap) | |
598 | { | |
599 | hbitmap_deserialize_finish(bitmap->bitmap); | |
600 | } | |
601 | ||
ebab2259 | 602 | void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector, |
6d078599 | 603 | int64_t nr_sectors) |
ebab2259 FZ |
604 | { |
605 | BdrvDirtyBitmap *bitmap; | |
2119882c PB |
606 | |
607 | if (QLIST_EMPTY(&bs->dirty_bitmaps)) { | |
608 | return; | |
609 | } | |
610 | ||
611 | bdrv_dirty_bitmaps_lock(bs); | |
ebab2259 FZ |
612 | QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) { |
613 | if (!bdrv_dirty_bitmap_enabled(bitmap)) { | |
614 | continue; | |
615 | } | |
616 | hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors); | |
617 | } | |
2119882c | 618 | bdrv_dirty_bitmaps_unlock(bs); |
ebab2259 FZ |
619 | } |
620 | ||
621 | /** | |
dc162c8e | 622 | * Advance a BdrvDirtyBitmapIter to an arbitrary offset. |
ebab2259 | 623 | */ |
dc162c8e | 624 | void bdrv_set_dirty_iter(BdrvDirtyBitmapIter *iter, int64_t sector_num) |
ebab2259 | 625 | { |
dc162c8e | 626 | hbitmap_iter_init(&iter->hbi, iter->hbi.hb, sector_num); |
ebab2259 FZ |
627 | } |
628 | ||
629 | int64_t bdrv_get_dirty_count(BdrvDirtyBitmap *bitmap) | |
630 | { | |
631 | return hbitmap_count(bitmap->bitmap); | |
632 | } | |
6d3f4049 FZ |
633 | |
634 | int64_t bdrv_get_meta_dirty_count(BdrvDirtyBitmap *bitmap) | |
635 | { | |
636 | return hbitmap_count(bitmap->meta); | |
637 | } |