tests: virtio-9p: rename PCI configuration test
[qemu.git] / block / dirty-bitmap.c
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"
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 * 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 {
40 HBitmap *bitmap; /* Dirty sector bitmap implementation */
41 HBitmap *meta; /* Meta dirty bitmap */
42 BdrvDirtyBitmap *successor; /* Anonymous child; implies frozen status */
43 char *name; /* Optional non-empty unique ID */
44 int64_t size; /* Size of the bitmap (Number of sectors) */
45 bool disabled; /* Bitmap is read-only */
46 int active_iterators; /* How many iterators are active */
47 QLIST_ENTRY(BdrvDirtyBitmap) list;
48 };
49
50 struct BdrvDirtyBitmapIter {
51 HBitmapIter hbi;
52 BdrvDirtyBitmap *bitmap;
53 };
54
55 BdrvDirtyBitmap *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
68 void 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
75 BdrvDirtyBitmap *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 /* bdrv_create_meta_dirty_bitmap
108 *
109 * Create a meta dirty bitmap that tracks the changes of bits in @bitmap. I.e.
110 * when a dirty status bit in @bitmap is changed (either from reset to set or
111 * the other way around), its respective meta dirty bitmap bit will be marked
112 * dirty as well.
113 *
114 * @bitmap: the block dirty bitmap for which to create a meta dirty bitmap.
115 * @chunk_size: how many bytes of bitmap data does each bit in the meta bitmap
116 * track.
117 */
118 void 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
126 void bdrv_release_meta_dirty_bitmap(BdrvDirtyBitmap *bitmap)
127 {
128 assert(bitmap->meta);
129 hbitmap_free_meta(bitmap->bitmap);
130 bitmap->meta = NULL;
131 }
132
133 int 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 /* To optimize: we can make hbitmap to internally check the range in a
141 * coarse level, or at least do it word by word. */
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
150 void 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
157 int64_t bdrv_dirty_bitmap_size(const BdrvDirtyBitmap *bitmap)
158 {
159 return bitmap->size;
160 }
161
162 const char *bdrv_dirty_bitmap_name(const BdrvDirtyBitmap *bitmap)
163 {
164 return bitmap->name;
165 }
166
167 bool bdrv_dirty_bitmap_frozen(BdrvDirtyBitmap *bitmap)
168 {
169 return bitmap->successor;
170 }
171
172 bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap *bitmap)
173 {
174 return !(bitmap->disabled || bitmap->successor);
175 }
176
177 DirtyBitmapStatus 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 * Create a successor bitmap destined to replace this bitmap after an operation.
190 * Requires that the bitmap is not frozen and has no successor.
191 */
192 int 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 /* Create an anonymous successor */
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 /* Successor will be on or off based on our current state. */
213 child->disabled = bitmap->disabled;
214
215 /* Install the successor and freeze the parent */
216 bitmap->successor = child;
217 return 0;
218 }
219
220 /**
221 * For a bitmap with a successor, yield our name to the successor,
222 * delete the old bitmap, and return a handle to the new bitmap.
223 */
224 BdrvDirtyBitmap *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 * In cases of failure where we can no longer safely delete the parent,
248 * we may wish to re-join the parent and child/successor.
249 * The merged parent will be un-frozen, but not explicitly re-enabled.
250 */
251 BdrvDirtyBitmap *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 * Truncates _all_ bitmaps attached to a BDS.
274 */
275 void 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
288 static 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
313 void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
314 {
315 bdrv_do_release_matching_dirty_bitmap(bs, bitmap, false);
316 }
317
318 /**
319 * Release all named dirty bitmaps attached to a BDS (for use in bdrv_close()).
320 * There must not be any frozen bitmaps attached.
321 */
322 void bdrv_release_named_dirty_bitmaps(BlockDriverState *bs)
323 {
324 bdrv_do_release_matching_dirty_bitmap(bs, NULL, true);
325 }
326
327 void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
328 {
329 assert(!bdrv_dirty_bitmap_frozen(bitmap));
330 bitmap->disabled = true;
331 }
332
333 void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
334 {
335 assert(!bdrv_dirty_bitmap_frozen(bitmap));
336 bitmap->disabled = false;
337 }
338
339 BlockDirtyInfoList *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
361 int 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 * Chooses a default granularity based on the existing cluster size,
373 * but clamped between [4K, 64K]. Defaults to 64K in the case that there
374 * is no cluster size information available.
375 */
376 uint32_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
391 uint32_t bdrv_dirty_bitmap_granularity(BdrvDirtyBitmap *bitmap)
392 {
393 return BDRV_SECTOR_SIZE << hbitmap_granularity(bitmap->bitmap);
394 }
395
396 uint32_t bdrv_dirty_bitmap_meta_granularity(BdrvDirtyBitmap *bitmap)
397 {
398 return BDRV_SECTOR_SIZE << hbitmap_granularity(bitmap->meta);
399 }
400
401 BdrvDirtyBitmapIter *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
411 BdrvDirtyBitmapIter *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
420 void 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
430 int64_t bdrv_dirty_iter_next(BdrvDirtyBitmapIter *iter)
431 {
432 return hbitmap_iter_next(&iter->hbi);
433 }
434
435 void 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
442 void 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
449 void 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
462 void 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
470 uint64_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
476 uint64_t bdrv_dirty_bitmap_serialization_align(const BdrvDirtyBitmap *bitmap)
477 {
478 return hbitmap_serialization_granularity(bitmap->bitmap);
479 }
480
481 void 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
488 void 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
495 void 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
502 void bdrv_dirty_bitmap_deserialize_finish(BdrvDirtyBitmap *bitmap)
503 {
504 hbitmap_deserialize_finish(bitmap->bitmap);
505 }
506
507 void 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 * Advance a BdrvDirtyBitmapIter to an arbitrary offset.
521 */
522 void bdrv_set_dirty_iter(BdrvDirtyBitmapIter *iter, int64_t sector_num)
523 {
524 hbitmap_iter_init(&iter->hbi, iter->hbi.hb, sector_num);
525 }
526
527 int64_t bdrv_get_dirty_count(BdrvDirtyBitmap *bitmap)
528 {
529 return hbitmap_count(bitmap->bitmap);
530 }
531
532 int64_t bdrv_get_meta_dirty_count(BdrvDirtyBitmap *bitmap)
533 {
534 return hbitmap_count(bitmap->meta);
535 }