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