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 | |
30 | struct 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 | |
57 | struct BdrvDirtyBitmapIter { |
58 | HBitmapIter hbi; |
59 | BdrvDirtyBitmap *bitmap; |
60 | }; |
61 | |
62 | static inline void bdrv_dirty_bitmaps_lock(BlockDriverState *bs) |
63 | { |
64 | qemu_mutex_lock(&bs->dirty_bitmap_mutex); |
65 | } |
66 | |
67 | static inline void bdrv_dirty_bitmaps_unlock(BlockDriverState *bs) |
68 | { |
69 | qemu_mutex_unlock(&bs->dirty_bitmap_mutex); |
70 | } |
71 | |
72 | void bdrv_dirty_bitmap_lock(BdrvDirtyBitmap *bitmap) |
73 | { |
74 | qemu_mutex_lock(bitmap->mutex); |
75 | } |
76 | |
77 | void bdrv_dirty_bitmap_unlock(BdrvDirtyBitmap *bitmap) |
78 | { |
79 | qemu_mutex_unlock(bitmap->mutex); |
80 | } |
81 | |
82 | /* Called with BQL or dirty_bitmap lock taken. */ |
83 | BdrvDirtyBitmap *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. */ |
97 | BdrvDirtyBitmap *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 | */ |
140 | void 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 | |
150 | void 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 | |
159 | int64_t bdrv_dirty_bitmap_size(const BdrvDirtyBitmap *bitmap) |
160 | { |
161 | return bitmap->size; |
162 | } |
163 | |
164 | const char *bdrv_dirty_bitmap_name(const BdrvDirtyBitmap *bitmap) |
165 | { |
166 | return bitmap->name; |
167 | } |
168 | |
169 | /* Called with BQL taken. */ |
170 | bool bdrv_dirty_bitmap_has_successor(BdrvDirtyBitmap *bitmap) |
171 | { |
172 | return bitmap->successor; |
173 | } |
174 | |
175 | static bool bdrv_dirty_bitmap_busy(const BdrvDirtyBitmap *bitmap) |
176 | { |
177 | return bitmap->busy; |
178 | } |
179 | |
180 | void 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. */ |
188 | bool 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 | */ |
215 | DirtyBitmapStatus 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. */ |
231 | static bool bdrv_dirty_bitmap_recording(BdrvDirtyBitmap *bitmap) |
232 | { |
233 | return !bitmap->disabled || (bitmap->successor && |
234 | !bitmap->successor->disabled); |
235 | } |
236 | |
237 | int 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 | */ |
270 | int 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 | |
302 | void bdrv_enable_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap) |
303 | { |
304 | bitmap->disabled = false; |
305 | } |
306 | |
307 | /* Called with BQL taken. */ |
308 | void 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. */ |
317 | static 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 | */ |
334 | BdrvDirtyBitmap *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 | */ |
366 | BdrvDirtyBitmap *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. */ |
391 | BdrvDirtyBitmap *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 | */ |
408 | void 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. */ |
424 | void 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 | */ |
437 | void 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 | */ |
458 | void 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 | |
467 | void 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 | |
474 | void 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 | |
481 | BlockDirtyInfoList *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 */ |
511 | bool bdrv_dirty_bitmap_get_locked(BdrvDirtyBitmap *bitmap, int64_t offset) |
512 | { |
513 | return hbitmap_get(bitmap->bitmap, offset); |
514 | } |
515 | |
516 | bool 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 | */ |
531 | uint32_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 | |
546 | uint32_t bdrv_dirty_bitmap_granularity(const BdrvDirtyBitmap *bitmap) |
547 | { |
548 | return 1U << hbitmap_granularity(bitmap->bitmap); |
549 | } |
550 | |
551 | BdrvDirtyBitmapIter *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 | |
560 | BdrvDirtyBitmapIter *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 | |
569 | void 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 | |
579 | int64_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 */ |
585 | void 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 | |
592 | void 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 */ |
601 | void 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 | |
608 | void 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 | |
616 | void 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 | |
631 | void 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 | |
639 | uint64_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 | |
645 | uint64_t bdrv_dirty_bitmap_serialization_align(const BdrvDirtyBitmap *bitmap) |
646 | { |
647 | return hbitmap_serialization_align(bitmap->bitmap); |
648 | } |
649 | |
650 | void 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 | |
657 | void 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 | |
664 | void 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 | |
671 | void 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 | |
678 | void bdrv_dirty_bitmap_deserialize_finish(BdrvDirtyBitmap *bitmap) |
679 | { |
680 | hbitmap_deserialize_finish(bitmap->bitmap); |
681 | } |
682 | |
683 | void 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 | */ |
705 | void bdrv_set_dirty_iter(BdrvDirtyBitmapIter *iter, int64_t offset) |
706 | { |
707 | hbitmap_iter_init(&iter->hbi, iter->hbi.hb, offset); |
708 | } |
709 | |
710 | int64_t bdrv_get_dirty_count(BdrvDirtyBitmap *bitmap) |
711 | { |
712 | return hbitmap_count(bitmap->bitmap); |
713 | } |
714 | |
715 | int64_t bdrv_get_meta_dirty_count(BdrvDirtyBitmap *bitmap) |
716 | { |
717 | return hbitmap_count(bitmap->meta); |
718 | } |
719 | |
720 | bool bdrv_dirty_bitmap_readonly(const BdrvDirtyBitmap *bitmap) |
721 | { |
722 | return bitmap->readonly; |
723 | } |
724 | |
725 | /* Called with BQL taken. */ |
726 | void 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 | |
733 | bool 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. */ |
746 | void 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. */ |
754 | void 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. */ |
764 | void 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 | |
771 | bool bdrv_dirty_bitmap_get_persistence(BdrvDirtyBitmap *bitmap) |
772 | { |
773 | return bitmap->persistent && !bitmap->skip_store; |
774 | } |
775 | |
776 | bool bdrv_dirty_bitmap_inconsistent(const BdrvDirtyBitmap *bitmap) |
777 | { |
778 | return bitmap->inconsistent; |
779 | } |
780 | |
781 | bool 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 | |
793 | BdrvDirtyBitmap *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 | |
800 | char *bdrv_dirty_bitmap_sha256(const BdrvDirtyBitmap *bitmap, Error **errp) |
801 | { |
802 | return hbitmap_sha256(bitmap->bitmap, errp); |
803 | } |
804 | |
805 | int64_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 | |
811 | bool 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 | */ |
823 | void 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 | |
849 | out: |
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 | */ |
864 | bool 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 | |