block/dirty-bitmap.c

   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 "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     QemuMutex *mutex;
  41     HBitmap *bitmap;            /* Dirty bitmap implementation */
  42     HBitmap *meta;              /* Meta dirty bitmap */
  43     bool qmp_locked;            /* Bitmap is locked, it can't be modified
  44                                    through QMP */
  45     BdrvDirtyBitmap *successor; /* Anonymous child; implies frozen status */
  46     char *name;                 /* Optional non-empty unique ID */
  47     int64_t size;               /* Size of the bitmap, in bytes */
  48     bool disabled;              /* Bitmap is disabled. It ignores all writes to
  49                                    the device */
  50     int active_iterators;       /* How many iterators are active */
  51     bool readonly;              /* Bitmap is read-only. This field also
  52                                    prevents the respective image from being
  53                                    modified (i.e. blocks writes and discards).
  54                                    Such operations must fail and both the image
  55                                    and this bitmap must remain unchanged while
  56                                    this flag is set. */
  57     bool persistent;            /* bitmap must be saved to owner disk image */
  58     QLIST_ENTRY(BdrvDirtyBitmap) list;
  59 };
  60
  61 struct BdrvDirtyBitmapIter {
  62     HBitmapIter hbi;
  63     BdrvDirtyBitmap *bitmap;
  64 };
  65
  66 static inline void bdrv_dirty_bitmaps_lock(BlockDriverState *bs)
  67 {
  68     qemu_mutex_lock(&bs->dirty_bitmap_mutex);
  69 }
  70
  71 static inline void bdrv_dirty_bitmaps_unlock(BlockDriverState *bs)
  72 {
  73     qemu_mutex_unlock(&bs->dirty_bitmap_mutex);
  74 }
  75
  76 void bdrv_dirty_bitmap_lock(BdrvDirtyBitmap *bitmap)
  77 {
  78     qemu_mutex_lock(bitmap->mutex);
  79 }
  80
  81 void bdrv_dirty_bitmap_unlock(BdrvDirtyBitmap *bitmap)
  82 {
  83     qemu_mutex_unlock(bitmap->mutex);
  84 }
  85
  86 /* Called with BQL or dirty_bitmap lock taken.  */
  87 BdrvDirtyBitmap *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 /* Called with BQL taken.  */
 101 BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs,
 102                                           uint32_t granularity,
 103                                           const char *name,
 104                                           Error **errp)
 105 {
 106     int64_t bitmap_size;
 107     BdrvDirtyBitmap *bitmap;
 108
 109     assert(is_power_of_2(granularity) && granularity >= BDRV_SECTOR_SIZE);
 110
 111     if (name && bdrv_find_dirty_bitmap(bs, name)) {
 112         error_setg(errp, "Bitmap already exists: %s", name);
 113         return NULL;
 114     }
 115     bitmap_size = bdrv_getlength(bs);
 116     if (bitmap_size < 0) {
 117         error_setg_errno(errp, -bitmap_size, "could not get length of device");
 118         errno = -bitmap_size;
 119         return NULL;
 120     }
 121     bitmap = g_new0(BdrvDirtyBitmap, 1);
 122     bitmap->mutex = &bs->dirty_bitmap_mutex;
 123     bitmap->bitmap = hbitmap_alloc(bitmap_size, ctz32(granularity));
 124     bitmap->size = bitmap_size;
 125     bitmap->name = g_strdup(name);
 126     bitmap->disabled = false;
 127     bdrv_dirty_bitmaps_lock(bs);
 128     QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list);
 129     bdrv_dirty_bitmaps_unlock(bs);
 130     return bitmap;
 131 }
 132
 133 /* bdrv_create_meta_dirty_bitmap
 134  *
 135  * Create a meta dirty bitmap that tracks the changes of bits in @bitmap. I.e.
 136  * when a dirty status bit in @bitmap is changed (either from reset to set or
 137  * the other way around), its respective meta dirty bitmap bit will be marked
 138  * dirty as well.
 139  *
 140  * @bitmap: the block dirty bitmap for which to create a meta dirty bitmap.
 141  * @chunk_size: how many bytes of bitmap data does each bit in the meta bitmap
 142  * track.
 143  */
 144 void bdrv_create_meta_dirty_bitmap(BdrvDirtyBitmap *bitmap,
 145                                    int chunk_size)
 146 {
 147     assert(!bitmap->meta);
 148     qemu_mutex_lock(bitmap->mutex);
 149     bitmap->meta = hbitmap_create_meta(bitmap->bitmap,
 150                                        chunk_size * BITS_PER_BYTE);
 151     qemu_mutex_unlock(bitmap->mutex);
 152 }
 153
 154 void bdrv_release_meta_dirty_bitmap(BdrvDirtyBitmap *bitmap)
 155 {
 156     assert(bitmap->meta);
 157     qemu_mutex_lock(bitmap->mutex);
 158     hbitmap_free_meta(bitmap->bitmap);
 159     bitmap->meta = NULL;
 160     qemu_mutex_unlock(bitmap->mutex);
 161 }
 162
 163 int64_t bdrv_dirty_bitmap_size(const BdrvDirtyBitmap *bitmap)
 164 {
 165     return bitmap->size;
 166 }
 167
 168 const char *bdrv_dirty_bitmap_name(const BdrvDirtyBitmap *bitmap)
 169 {
 170     return bitmap->name;
 171 }
 172
 173 /* Called with BQL taken.  */
 174 bool bdrv_dirty_bitmap_frozen(BdrvDirtyBitmap *bitmap)
 175 {
 176     return bitmap->successor;
 177 }
 178
 179 void bdrv_dirty_bitmap_set_qmp_locked(BdrvDirtyBitmap *bitmap, bool qmp_locked)
 180 {
 181     qemu_mutex_lock(bitmap->mutex);
 182     bitmap->qmp_locked = qmp_locked;
 183     qemu_mutex_unlock(bitmap->mutex);
 184 }
 185
 186 bool bdrv_dirty_bitmap_qmp_locked(BdrvDirtyBitmap *bitmap)
 187 {
 188     return bitmap->qmp_locked;
 189 }
 190
 191 /* Called with BQL taken.  */
 192 bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap *bitmap)
 193 {
 194     return !(bitmap->disabled || bitmap->successor);
 195 }
 196
 197 /* Called with BQL taken.  */
 198 DirtyBitmapStatus bdrv_dirty_bitmap_status(BdrvDirtyBitmap *bitmap)
 199 {
 200     if (bdrv_dirty_bitmap_frozen(bitmap)) {
 201         return DIRTY_BITMAP_STATUS_FROZEN;
 202     } else if (bdrv_dirty_bitmap_qmp_locked(bitmap)) {
 203         return DIRTY_BITMAP_STATUS_LOCKED;
 204     } else if (!bdrv_dirty_bitmap_enabled(bitmap)) {
 205         return DIRTY_BITMAP_STATUS_DISABLED;
 206     } else {
 207         return DIRTY_BITMAP_STATUS_ACTIVE;
 208     }
 209 }
 210
 211 /**
 212  * Create a successor bitmap destined to replace this bitmap after an operation.
 213  * Requires that the bitmap is not frozen and has no successor.
 214  * Called with BQL taken.
 215  */
 216 int bdrv_dirty_bitmap_create_successor(BlockDriverState *bs,
 217                                        BdrvDirtyBitmap *bitmap, Error **errp)
 218 {
 219     uint64_t granularity;
 220     BdrvDirtyBitmap *child;
 221
 222     if (bdrv_dirty_bitmap_frozen(bitmap)) {
 223         error_setg(errp, "Cannot create a successor for a bitmap that is "
 224                    "currently frozen");
 225         return -1;
 226     }
 227     assert(!bitmap->successor);
 228
 229     /* Create an anonymous successor */
 230     granularity = bdrv_dirty_bitmap_granularity(bitmap);
 231     child = bdrv_create_dirty_bitmap(bs, granularity, NULL, errp);
 232     if (!child) {
 233         return -1;
 234     }
 235
 236     /* Successor will be on or off based on our current state. */
 237     child->disabled = bitmap->disabled;
 238
 239     /* Install the successor and freeze the parent */
 240     bitmap->successor = child;
 241     return 0;
 242 }
 243
 244 /* Called with BQL taken. */
 245 void bdrv_dirty_bitmap_enable_successor(BdrvDirtyBitmap *bitmap)
 246 {
 247     qemu_mutex_lock(bitmap->mutex);
 248     bdrv_enable_dirty_bitmap(bitmap->successor);
 249     qemu_mutex_unlock(bitmap->mutex);
 250 }
 251
 252 /* Called within bdrv_dirty_bitmap_lock..unlock */
 253 static void bdrv_do_release_matching_dirty_bitmap_locked(
 254     BlockDriverState *bs, BdrvDirtyBitmap *bitmap,
 255     bool (*cond)(BdrvDirtyBitmap *bitmap))
 256 {
 257     BdrvDirtyBitmap *bm, *next;
 258
 259     QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) {
 260         if ((!bitmap || bm == bitmap) && (!cond || cond(bm))) {
 261             assert(!bm->active_iterators);
 262             assert(!bdrv_dirty_bitmap_frozen(bm));
 263             assert(!bm->meta);
 264             QLIST_REMOVE(bm, list);
 265             hbitmap_free(bm->bitmap);
 266             g_free(bm->name);
 267             g_free(bm);
 268
 269             if (bitmap) {
 270                 return;
 271             }
 272         }
 273     }
 274
 275     if (bitmap) {
 276         abort();
 277     }
 278 }
 279
 280 /* Called with BQL taken.  */
 281 static void bdrv_do_release_matching_dirty_bitmap(
 282     BlockDriverState *bs, BdrvDirtyBitmap *bitmap,
 283     bool (*cond)(BdrvDirtyBitmap *bitmap))
 284 {
 285     bdrv_dirty_bitmaps_lock(bs);
 286     bdrv_do_release_matching_dirty_bitmap_locked(bs, bitmap, cond);
 287     bdrv_dirty_bitmaps_unlock(bs);
 288 }
 289
 290 /* Called within bdrv_dirty_bitmap_lock..unlock */
 291 static void bdrv_release_dirty_bitmap_locked(BlockDriverState *bs,
 292                                              BdrvDirtyBitmap *bitmap)
 293 {
 294     bdrv_do_release_matching_dirty_bitmap_locked(bs, bitmap, NULL);
 295 }
 296
 297 /**
 298  * For a bitmap with a successor, yield our name to the successor,
 299  * delete the old bitmap, and return a handle to the new bitmap.
 300  * Called with BQL taken.
 301  */
 302 BdrvDirtyBitmap *bdrv_dirty_bitmap_abdicate(BlockDriverState *bs,
 303                                             BdrvDirtyBitmap *bitmap,
 304                                             Error **errp)
 305 {
 306     char *name;
 307     BdrvDirtyBitmap *successor = bitmap->successor;
 308
 309     if (successor == NULL) {
 310         error_setg(errp, "Cannot relinquish control if "
 311                    "there's no successor present");
 312         return NULL;
 313     }
 314
 315     name = bitmap->name;
 316     bitmap->name = NULL;
 317     successor->name = name;
 318     bitmap->successor = NULL;
 319     successor->persistent = bitmap->persistent;
 320     bitmap->persistent = false;
 321     bdrv_release_dirty_bitmap(bs, bitmap);
 322
 323     return successor;
 324 }
 325
 326 /**
 327  * In cases of failure where we can no longer safely delete the parent,
 328  * we may wish to re-join the parent and child/successor.
 329  * The merged parent will be un-frozen, but not explicitly re-enabled.
 330  * Called within bdrv_dirty_bitmap_lock..unlock and with BQL taken.
 331  */
 332 BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap_locked(BlockDriverState *bs,
 333                                                   BdrvDirtyBitmap *parent,
 334                                                   Error **errp)
 335 {
 336     BdrvDirtyBitmap *successor = parent->successor;
 337
 338     if (!successor) {
 339         error_setg(errp, "Cannot reclaim a successor when none is present");
 340         return NULL;
 341     }
 342
 343     if (!hbitmap_merge(parent->bitmap, successor->bitmap)) {
 344         error_setg(errp, "Merging of parent and successor bitmap failed");
 345         return NULL;
 346     }
 347     bdrv_release_dirty_bitmap_locked(bs, successor);
 348     parent->successor = NULL;
 349
 350     return parent;
 351 }
 352
 353 /* Called with BQL taken. */
 354 BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap(BlockDriverState *bs,
 355                                            BdrvDirtyBitmap *parent,
 356                                            Error **errp)
 357 {
 358     BdrvDirtyBitmap *ret;
 359
 360     qemu_mutex_lock(parent->mutex);
 361     ret = bdrv_reclaim_dirty_bitmap_locked(bs, parent, errp);
 362     qemu_mutex_unlock(parent->mutex);
 363
 364     return ret;
 365 }
 366
 367 /**
 368  * Truncates _all_ bitmaps attached to a BDS.
 369  * Called with BQL taken.
 370  */
 371 void bdrv_dirty_bitmap_truncate(BlockDriverState *bs, int64_t bytes)
 372 {
 373     BdrvDirtyBitmap *bitmap;
 374
 375     bdrv_dirty_bitmaps_lock(bs);
 376     QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
 377         assert(!bdrv_dirty_bitmap_frozen(bitmap));
 378         assert(!bitmap->active_iterators);
 379         hbitmap_truncate(bitmap->bitmap, bytes);
 380         bitmap->size = bytes;
 381     }
 382     bdrv_dirty_bitmaps_unlock(bs);
 383 }
 384
 385 static bool bdrv_dirty_bitmap_has_name(BdrvDirtyBitmap *bitmap)
 386 {
 387     return !!bdrv_dirty_bitmap_name(bitmap);
 388 }
 389
 390 /* Called with BQL taken.  */
 391 void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
 392 {
 393     bdrv_do_release_matching_dirty_bitmap(bs, bitmap, NULL);
 394 }
 395
 396 /**
 397  * Release all named dirty bitmaps attached to a BDS (for use in bdrv_close()).
 398  * There must not be any frozen bitmaps attached.
 399  * This function does not remove persistent bitmaps from the storage.
 400  * Called with BQL taken.
 401  */
 402 void bdrv_release_named_dirty_bitmaps(BlockDriverState *bs)
 403 {
 404     bdrv_do_release_matching_dirty_bitmap(bs, NULL, bdrv_dirty_bitmap_has_name);
 405 }
 406
 407 /**
 408  * Release all persistent dirty bitmaps attached to a BDS (for use in
 409  * bdrv_inactivate_recurse()).
 410  * There must not be any frozen bitmaps attached.
 411  * This function does not remove persistent bitmaps from the storage.
 412  */
 413 void bdrv_release_persistent_dirty_bitmaps(BlockDriverState *bs)
 414 {
 415     bdrv_do_release_matching_dirty_bitmap(bs, NULL,
 416                                           bdrv_dirty_bitmap_get_persistance);
 417 }
 418
 419 /**
 420  * Remove persistent dirty bitmap from the storage if it exists.
 421  * Absence of bitmap is not an error, because we have the following scenario:
 422  * BdrvDirtyBitmap can have .persistent = true but not yet saved and have no
 423  * stored version. For such bitmap bdrv_remove_persistent_dirty_bitmap() should
 424  * not fail.
 425  * This function doesn't release corresponding BdrvDirtyBitmap.
 426  */
 427 void bdrv_remove_persistent_dirty_bitmap(BlockDriverState *bs,
 428                                          const char *name,
 429                                          Error **errp)
 430 {
 431     if (bs->drv && bs->drv->bdrv_remove_persistent_dirty_bitmap) {
 432         bs->drv->bdrv_remove_persistent_dirty_bitmap(bs, name, errp);
 433     }
 434 }
 435
 436 /* Called with BQL taken.  */
 437 void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
 438 {
 439     assert(!bdrv_dirty_bitmap_frozen(bitmap));
 440     bitmap->disabled = true;
 441 }
 442
 443 /* Called with BQL taken.  */
 444 void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
 445 {
 446     assert(!bdrv_dirty_bitmap_frozen(bitmap));
 447     bitmap->disabled = false;
 448 }
 449
 450 BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs)
 451 {
 452     BdrvDirtyBitmap *bm;
 453     BlockDirtyInfoList *list = NULL;
 454     BlockDirtyInfoList **plist = &list;
 455
 456     bdrv_dirty_bitmaps_lock(bs);
 457     QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
 458         BlockDirtyInfo *info = g_new0(BlockDirtyInfo, 1);
 459         BlockDirtyInfoList *entry = g_new0(BlockDirtyInfoList, 1);
 460         info->count = bdrv_get_dirty_count(bm);
 461         info->granularity = bdrv_dirty_bitmap_granularity(bm);
 462         info->has_name = !!bm->name;
 463         info->name = g_strdup(bm->name);
 464         info->status = bdrv_dirty_bitmap_status(bm);
 465         entry->value = info;
 466         *plist = entry;
 467         plist = &entry->next;
 468     }
 469     bdrv_dirty_bitmaps_unlock(bs);
 470
 471     return list;
 472 }
 473
 474 /* Called within bdrv_dirty_bitmap_lock..unlock */
 475 bool bdrv_get_dirty_locked(BlockDriverState *bs, BdrvDirtyBitmap *bitmap,
 476                            int64_t offset)
 477 {
 478     if (bitmap) {
 479         return hbitmap_get(bitmap->bitmap, offset);
 480     } else {
 481         return false;
 482     }
 483 }
 484
 485 /**
 486  * Chooses a default granularity based on the existing cluster size,
 487  * but clamped between [4K, 64K]. Defaults to 64K in the case that there
 488  * is no cluster size information available.
 489  */
 490 uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState *bs)
 491 {
 492     BlockDriverInfo bdi;
 493     uint32_t granularity;
 494
 495     if (bdrv_get_info(bs, &bdi) >= 0 && bdi.cluster_size > 0) {
 496         granularity = MAX(4096, bdi.cluster_size);
 497         granularity = MIN(65536, granularity);
 498     } else {
 499         granularity = 65536;
 500     }
 501
 502     return granularity;
 503 }
 504
 505 uint32_t bdrv_dirty_bitmap_granularity(const BdrvDirtyBitmap *bitmap)
 506 {
 507     return 1U << hbitmap_granularity(bitmap->bitmap);
 508 }
 509
 510 BdrvDirtyBitmapIter *bdrv_dirty_iter_new(BdrvDirtyBitmap *bitmap)
 511 {
 512     BdrvDirtyBitmapIter *iter = g_new(BdrvDirtyBitmapIter, 1);
 513     hbitmap_iter_init(&iter->hbi, bitmap->bitmap, 0);
 514     iter->bitmap = bitmap;
 515     bitmap->active_iterators++;
 516     return iter;
 517 }
 518
 519 BdrvDirtyBitmapIter *bdrv_dirty_meta_iter_new(BdrvDirtyBitmap *bitmap)
 520 {
 521     BdrvDirtyBitmapIter *iter = g_new(BdrvDirtyBitmapIter, 1);
 522     hbitmap_iter_init(&iter->hbi, bitmap->meta, 0);
 523     iter->bitmap = bitmap;
 524     bitmap->active_iterators++;
 525     return iter;
 526 }
 527
 528 void bdrv_dirty_iter_free(BdrvDirtyBitmapIter *iter)
 529 {
 530     if (!iter) {
 531         return;
 532     }
 533     assert(iter->bitmap->active_iterators > 0);
 534     iter->bitmap->active_iterators--;
 535     g_free(iter);
 536 }
 537
 538 int64_t bdrv_dirty_iter_next(BdrvDirtyBitmapIter *iter)
 539 {
 540     return hbitmap_iter_next(&iter->hbi);
 541 }
 542
 543 /* Called within bdrv_dirty_bitmap_lock..unlock */
 544 void bdrv_set_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap,
 545                                   int64_t offset, int64_t bytes)
 546 {
 547     assert(bdrv_dirty_bitmap_enabled(bitmap));
 548     assert(!bdrv_dirty_bitmap_readonly(bitmap));
 549     hbitmap_set(bitmap->bitmap, offset, bytes);
 550 }
 551
 552 void bdrv_set_dirty_bitmap(BdrvDirtyBitmap *bitmap,
 553                            int64_t offset, int64_t bytes)
 554 {
 555     bdrv_dirty_bitmap_lock(bitmap);
 556     bdrv_set_dirty_bitmap_locked(bitmap, offset, bytes);
 557     bdrv_dirty_bitmap_unlock(bitmap);
 558 }
 559
 560 /* Called within bdrv_dirty_bitmap_lock..unlock */
 561 void bdrv_reset_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap,
 562                                     int64_t offset, int64_t bytes)
 563 {
 564     assert(bdrv_dirty_bitmap_enabled(bitmap));
 565     assert(!bdrv_dirty_bitmap_readonly(bitmap));
 566     hbitmap_reset(bitmap->bitmap, offset, bytes);
 567 }
 568
 569 void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap *bitmap,
 570                              int64_t offset, int64_t bytes)
 571 {
 572     bdrv_dirty_bitmap_lock(bitmap);
 573     bdrv_reset_dirty_bitmap_locked(bitmap, offset, bytes);
 574     bdrv_dirty_bitmap_unlock(bitmap);
 575 }
 576
 577 void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap **out)
 578 {
 579     assert(bdrv_dirty_bitmap_enabled(bitmap));
 580     assert(!bdrv_dirty_bitmap_readonly(bitmap));
 581     bdrv_dirty_bitmap_lock(bitmap);
 582     if (!out) {
 583         hbitmap_reset_all(bitmap->bitmap);
 584     } else {
 585         HBitmap *backup = bitmap->bitmap;
 586         bitmap->bitmap = hbitmap_alloc(bitmap->size,
 587                                        hbitmap_granularity(backup));
 588         *out = backup;
 589     }
 590     bdrv_dirty_bitmap_unlock(bitmap);
 591 }
 592
 593 void bdrv_undo_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap *in)
 594 {
 595     HBitmap *tmp = bitmap->bitmap;
 596     assert(bdrv_dirty_bitmap_enabled(bitmap));
 597     assert(!bdrv_dirty_bitmap_readonly(bitmap));
 598     bitmap->bitmap = in;
 599     hbitmap_free(tmp);
 600 }
 601
 602 uint64_t bdrv_dirty_bitmap_serialization_size(const BdrvDirtyBitmap *bitmap,
 603                                               uint64_t offset, uint64_t bytes)
 604 {
 605     return hbitmap_serialization_size(bitmap->bitmap, offset, bytes);
 606 }
 607
 608 uint64_t bdrv_dirty_bitmap_serialization_align(const BdrvDirtyBitmap *bitmap)
 609 {
 610     return hbitmap_serialization_align(bitmap->bitmap);
 611 }
 612
 613 void bdrv_dirty_bitmap_serialize_part(const BdrvDirtyBitmap *bitmap,
 614                                       uint8_t *buf, uint64_t offset,
 615                                       uint64_t bytes)
 616 {
 617     hbitmap_serialize_part(bitmap->bitmap, buf, offset, bytes);
 618 }
 619
 620 void bdrv_dirty_bitmap_deserialize_part(BdrvDirtyBitmap *bitmap,
 621                                         uint8_t *buf, uint64_t offset,
 622                                         uint64_t bytes, bool finish)
 623 {
 624     hbitmap_deserialize_part(bitmap->bitmap, buf, offset, bytes, finish);
 625 }
 626
 627 void bdrv_dirty_bitmap_deserialize_zeroes(BdrvDirtyBitmap *bitmap,
 628                                           uint64_t offset, uint64_t bytes,
 629                                           bool finish)
 630 {
 631     hbitmap_deserialize_zeroes(bitmap->bitmap, offset, bytes, finish);
 632 }
 633
 634 void bdrv_dirty_bitmap_deserialize_ones(BdrvDirtyBitmap *bitmap,
 635                                         uint64_t offset, uint64_t bytes,
 636                                         bool finish)
 637 {
 638     hbitmap_deserialize_ones(bitmap->bitmap, offset, bytes, finish);
 639 }
 640
 641 void bdrv_dirty_bitmap_deserialize_finish(BdrvDirtyBitmap *bitmap)
 642 {
 643     hbitmap_deserialize_finish(bitmap->bitmap);
 644 }
 645
 646 void bdrv_set_dirty(BlockDriverState *bs, int64_t offset, int64_t bytes)
 647 {
 648     BdrvDirtyBitmap *bitmap;
 649
 650     if (QLIST_EMPTY(&bs->dirty_bitmaps)) {
 651         return;
 652     }
 653
 654     bdrv_dirty_bitmaps_lock(bs);
 655     QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
 656         if (!bdrv_dirty_bitmap_enabled(bitmap)) {
 657             continue;
 658         }
 659         assert(!bdrv_dirty_bitmap_readonly(bitmap));
 660         hbitmap_set(bitmap->bitmap, offset, bytes);
 661     }
 662     bdrv_dirty_bitmaps_unlock(bs);
 663 }
 664
 665 /**
 666  * Advance a BdrvDirtyBitmapIter to an arbitrary offset.
 667  */
 668 void bdrv_set_dirty_iter(BdrvDirtyBitmapIter *iter, int64_t offset)
 669 {
 670     hbitmap_iter_init(&iter->hbi, iter->hbi.hb, offset);
 671 }
 672
 673 int64_t bdrv_get_dirty_count(BdrvDirtyBitmap *bitmap)
 674 {
 675     return hbitmap_count(bitmap->bitmap);
 676 }
 677
 678 int64_t bdrv_get_meta_dirty_count(BdrvDirtyBitmap *bitmap)
 679 {
 680     return hbitmap_count(bitmap->meta);
 681 }
 682
 683 bool bdrv_dirty_bitmap_readonly(const BdrvDirtyBitmap *bitmap)
 684 {
 685     return bitmap->readonly;
 686 }
 687
 688 /* Called with BQL taken. */
 689 void bdrv_dirty_bitmap_set_readonly(BdrvDirtyBitmap *bitmap, bool value)
 690 {
 691     qemu_mutex_lock(bitmap->mutex);
 692     bitmap->readonly = value;
 693     qemu_mutex_unlock(bitmap->mutex);
 694 }
 695
 696 bool bdrv_has_readonly_bitmaps(BlockDriverState *bs)
 697 {
 698     BdrvDirtyBitmap *bm;
 699     QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
 700         if (bm->readonly) {
 701             return true;
 702         }
 703     }
 704
 705     return false;
 706 }
 707
 708 /* Called with BQL taken. */
 709 void bdrv_dirty_bitmap_set_persistance(BdrvDirtyBitmap *bitmap, bool persistent)
 710 {
 711     qemu_mutex_lock(bitmap->mutex);
 712     bitmap->persistent = persistent;
 713     qemu_mutex_unlock(bitmap->mutex);
 714 }
 715
 716 bool bdrv_dirty_bitmap_get_persistance(BdrvDirtyBitmap *bitmap)
 717 {
 718     return bitmap->persistent;
 719 }
 720
 721 bool bdrv_has_changed_persistent_bitmaps(BlockDriverState *bs)
 722 {
 723     BdrvDirtyBitmap *bm;
 724     QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
 725         if (bm->persistent && !bm->readonly) {
 726             return true;
 727         }
 728     }
 729
 730     return false;
 731 }
 732
 733 BdrvDirtyBitmap *bdrv_dirty_bitmap_next(BlockDriverState *bs,
 734                                         BdrvDirtyBitmap *bitmap)
 735 {
 736     return bitmap == NULL ? QLIST_FIRST(&bs->dirty_bitmaps) :
 737                             QLIST_NEXT(bitmap, list);
 738 }
 739
 740 char *bdrv_dirty_bitmap_sha256(const BdrvDirtyBitmap *bitmap, Error **errp)
 741 {
 742     return hbitmap_sha256(bitmap->bitmap, errp);
 743 }
 744
 745 int64_t bdrv_dirty_bitmap_next_zero(BdrvDirtyBitmap *bitmap, uint64_t offset)
 746 {
 747     return hbitmap_next_zero(bitmap->bitmap, offset);
 748 }