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