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