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