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