block/dirty-bitmap.c

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