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 /**
 170  * bdrv_dirty_bitmap_status: This API is now deprecated.
 171  * Called with BQL taken.
 172  *
 173  * A BdrvDirtyBitmap can be in four possible user-visible states:
 174  * (1) Active:   successor is NULL, and disabled is false: full r/w mode
 175  * (2) Disabled: successor is NULL, and disabled is true: qualified r/w mode,
 176  *               guest writes are dropped, but monitor writes are possible,
 177  *               through commands like merge and clear.
 178  * (3) Frozen:   successor is not NULL.
 179  *               A frozen bitmap cannot be renamed, deleted, cleared, set,
 180  *               enabled, merged to, etc. A frozen bitmap can only abdicate()
 181  *               or reclaim().
 182  *               In this state, the anonymous successor bitmap may be either
 183  *               Active and recording writes from the guest (e.g. backup jobs),
 184  *               or it can be Disabled and not recording writes.
 185  * (4) Locked:   Whether Active or Disabled, the user cannot modify this bitmap
 186  *               in any way from the monitor.
 187  * (5) Inconsistent: This is a persistent bitmap whose "in use" bit is set, and
 188  *                   is unusable by QEMU. It can be deleted to remove it from
 189  *                   the qcow2.
 190  */
 191 DirtyBitmapStatus bdrv_dirty_bitmap_status(BdrvDirtyBitmap *bitmap)
 192 {
 193     if (bdrv_dirty_bitmap_inconsistent(bitmap)) {
 194         return DIRTY_BITMAP_STATUS_INCONSISTENT;
 195     } else if (bdrv_dirty_bitmap_has_successor(bitmap)) {
 196         return DIRTY_BITMAP_STATUS_FROZEN;
 197     } else if (bdrv_dirty_bitmap_busy(bitmap)) {
 198         return DIRTY_BITMAP_STATUS_LOCKED;
 199     } else if (!bdrv_dirty_bitmap_enabled(bitmap)) {
 200         return DIRTY_BITMAP_STATUS_DISABLED;
 201     } else {
 202         return DIRTY_BITMAP_STATUS_ACTIVE;
 203     }
 204 }
 205
 206 /* Called with BQL taken.  */
 207 static bool bdrv_dirty_bitmap_recording(BdrvDirtyBitmap *bitmap)
 208 {
 209     return !bitmap->disabled || (bitmap->successor &&
 210                                  !bitmap->successor->disabled);
 211 }
 212
 213 int bdrv_dirty_bitmap_check(const BdrvDirtyBitmap *bitmap, uint32_t flags,
 214                             Error **errp)
 215 {
 216     if ((flags & BDRV_BITMAP_BUSY) && bdrv_dirty_bitmap_busy(bitmap)) {
 217         error_setg(errp, "Bitmap '%s' is currently in use by another"
 218                    " operation and cannot be used", bitmap->name);
 219         return -1;
 220     }
 221
 222     if ((flags & BDRV_BITMAP_RO) && bdrv_dirty_bitmap_readonly(bitmap)) {
 223         error_setg(errp, "Bitmap '%s' is readonly and cannot be modified",
 224                    bitmap->name);
 225         return -1;
 226     }
 227
 228     if ((flags & BDRV_BITMAP_INCONSISTENT) &&
 229         bdrv_dirty_bitmap_inconsistent(bitmap)) {
 230         error_setg(errp, "Bitmap '%s' is inconsistent and cannot be used",
 231                    bitmap->name);
 232         error_append_hint(errp, "Try block-dirty-bitmap-remove to delete"
 233                           " this bitmap from disk");
 234         return -1;
 235     }
 236
 237     return 0;
 238 }
 239
 240 /**
 241  * Create a successor bitmap destined to replace this bitmap after an operation.
 242  * Requires that the bitmap is not marked busy and has no successor.
 243  * The successor will be enabled if the parent bitmap was.
 244  * Called with BQL taken.
 245  */
 246 int bdrv_dirty_bitmap_create_successor(BdrvDirtyBitmap *bitmap, Error **errp)
 247 {
 248     uint64_t granularity;
 249     BdrvDirtyBitmap *child;
 250
 251     if (bdrv_dirty_bitmap_check(bitmap, BDRV_BITMAP_BUSY, errp)) {
 252         return -1;
 253     }
 254     if (bdrv_dirty_bitmap_has_successor(bitmap)) {
 255         error_setg(errp, "Cannot create a successor for a bitmap that already "
 256                    "has one");
 257         return -1;
 258     }
 259
 260     /* Create an anonymous successor */
 261     granularity = bdrv_dirty_bitmap_granularity(bitmap);
 262     child = bdrv_create_dirty_bitmap(bitmap->bs, granularity, NULL, errp);
 263     if (!child) {
 264         return -1;
 265     }
 266
 267     /* Successor will be on or off based on our current state. */
 268     child->disabled = bitmap->disabled;
 269     bitmap->disabled = true;
 270
 271     /* Install the successor and mark the parent as busy */
 272     bitmap->successor = child;
 273     bitmap->busy = true;
 274     return 0;
 275 }
 276
 277 void bdrv_enable_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap)
 278 {
 279     bitmap->disabled = false;
 280 }
 281
 282 /* Called with BQL taken. */
 283 void bdrv_dirty_bitmap_enable_successor(BdrvDirtyBitmap *bitmap)
 284 {
 285     assert(bitmap->bs == bitmap->successor->bs);
 286     bdrv_dirty_bitmaps_lock(bitmap->bs);
 287     bdrv_enable_dirty_bitmap_locked(bitmap->successor);
 288     bdrv_dirty_bitmaps_unlock(bitmap->bs);
 289 }
 290
 291 /* Called within bdrv_dirty_bitmap_lock..unlock and with BQL taken.  */
 292 static void bdrv_release_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap)
 293 {
 294     assert(!bitmap->active_iterators);
 295     assert(!bdrv_dirty_bitmap_busy(bitmap));
 296     assert(!bdrv_dirty_bitmap_has_successor(bitmap));
 297     QLIST_REMOVE(bitmap, list);
 298     hbitmap_free(bitmap->bitmap);
 299     g_free(bitmap->name);
 300     g_free(bitmap);
 301 }
 302
 303 /**
 304  * For a bitmap with a successor, yield our name to the successor,
 305  * delete the old bitmap, and return a handle to the new bitmap.
 306  * Called with BQL taken.
 307  */
 308 BdrvDirtyBitmap *bdrv_dirty_bitmap_abdicate(BdrvDirtyBitmap *bitmap,
 309                                             Error **errp)
 310 {
 311     char *name;
 312     BdrvDirtyBitmap *successor = bitmap->successor;
 313
 314     if (successor == NULL) {
 315         error_setg(errp, "Cannot relinquish control if "
 316                    "there's no successor present");
 317         return NULL;
 318     }
 319
 320     name = bitmap->name;
 321     bitmap->name = NULL;
 322     successor->name = name;
 323     bitmap->successor = NULL;
 324     successor->persistent = bitmap->persistent;
 325     bitmap->persistent = false;
 326     bitmap->busy = false;
 327     bdrv_release_dirty_bitmap(bitmap);
 328
 329     return successor;
 330 }
 331
 332 /**
 333  * In cases of failure where we can no longer safely delete the parent,
 334  * we may wish to re-join the parent and child/successor.
 335  * The merged parent will be marked as not busy.
 336  * The marged parent will be enabled if and only if the successor was enabled.
 337  * Called within bdrv_dirty_bitmap_lock..unlock and with BQL taken.
 338  */
 339 BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap_locked(BdrvDirtyBitmap *parent,
 340                                                   Error **errp)
 341 {
 342     BdrvDirtyBitmap *successor = parent->successor;
 343
 344     if (!successor) {
 345         error_setg(errp, "Cannot reclaim a successor when none is present");
 346         return NULL;
 347     }
 348
 349     if (!hbitmap_merge(parent->bitmap, successor->bitmap, parent->bitmap)) {
 350         error_setg(errp, "Merging of parent and successor bitmap failed");
 351         return NULL;
 352     }
 353
 354     parent->disabled = successor->disabled;
 355     parent->busy = false;
 356     bdrv_release_dirty_bitmap_locked(successor);
 357     parent->successor = NULL;
 358
 359     return parent;
 360 }
 361
 362 /* Called with BQL taken. */
 363 BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap(BdrvDirtyBitmap *parent,
 364                                            Error **errp)
 365 {
 366     BdrvDirtyBitmap *ret;
 367
 368     bdrv_dirty_bitmaps_lock(parent->bs);
 369     ret = bdrv_reclaim_dirty_bitmap_locked(parent, errp);
 370     bdrv_dirty_bitmaps_unlock(parent->bs);
 371
 372     return ret;
 373 }
 374
 375 /**
 376  * Truncates _all_ bitmaps attached to a BDS.
 377  * Called with BQL taken.
 378  */
 379 void bdrv_dirty_bitmap_truncate(BlockDriverState *bs, int64_t bytes)
 380 {
 381     BdrvDirtyBitmap *bitmap;
 382
 383     bdrv_dirty_bitmaps_lock(bs);
 384     QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
 385         assert(!bdrv_dirty_bitmap_busy(bitmap));
 386         assert(!bdrv_dirty_bitmap_has_successor(bitmap));
 387         assert(!bitmap->active_iterators);
 388         hbitmap_truncate(bitmap->bitmap, bytes);
 389         bitmap->size = bytes;
 390     }
 391     bdrv_dirty_bitmaps_unlock(bs);
 392 }
 393
 394 /* Called with BQL taken.  */
 395 void bdrv_release_dirty_bitmap(BdrvDirtyBitmap *bitmap)
 396 {
 397     BlockDriverState *bs = bitmap->bs;
 398
 399     bdrv_dirty_bitmaps_lock(bs);
 400     bdrv_release_dirty_bitmap_locked(bitmap);
 401     bdrv_dirty_bitmaps_unlock(bs);
 402 }
 403
 404 /**
 405  * Release all named dirty bitmaps attached to a BDS (for use in bdrv_close()).
 406  * There must not be any busy bitmaps attached.
 407  * This function does not remove persistent bitmaps from the storage.
 408  * Called with BQL taken.
 409  */
 410 void bdrv_release_named_dirty_bitmaps(BlockDriverState *bs)
 411 {
 412     BdrvDirtyBitmap *bm, *next;
 413
 414     bdrv_dirty_bitmaps_lock(bs);
 415     QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) {
 416         if (bdrv_dirty_bitmap_name(bm)) {
 417             bdrv_release_dirty_bitmap_locked(bm);
 418         }
 419     }
 420     bdrv_dirty_bitmaps_unlock(bs);
 421 }
 422
 423 /**
 424  * Remove persistent dirty bitmap from the storage if it exists.
 425  * Absence of bitmap is not an error, because we have the following scenario:
 426  * BdrvDirtyBitmap can have .persistent = true but not yet saved and have no
 427  * stored version. For such bitmap bdrv_remove_persistent_dirty_bitmap() should
 428  * not fail.
 429  * This function doesn't release corresponding BdrvDirtyBitmap.
 430  */
 431 static int coroutine_fn
 432 bdrv_co_remove_persistent_dirty_bitmap(BlockDriverState *bs, const char *name,
 433                                        Error **errp)
 434 {
 435     if (bs->drv && bs->drv->bdrv_co_remove_persistent_dirty_bitmap) {
 436         return bs->drv->bdrv_co_remove_persistent_dirty_bitmap(bs, name, errp);
 437     }
 438
 439     return 0;
 440 }
 441
 442 typedef struct BdrvRemovePersistentDirtyBitmapCo {
 443     BlockDriverState *bs;
 444     const char *name;
 445     Error **errp;
 446     int ret;
 447 } BdrvRemovePersistentDirtyBitmapCo;
 448
 449 static void coroutine_fn
 450 bdrv_co_remove_persistent_dirty_bitmap_entry(void *opaque)
 451 {
 452     BdrvRemovePersistentDirtyBitmapCo *s = opaque;
 453
 454     s->ret = bdrv_co_remove_persistent_dirty_bitmap(s->bs, s->name, s->errp);
 455     aio_wait_kick();
 456 }
 457
 458 int bdrv_remove_persistent_dirty_bitmap(BlockDriverState *bs, const char *name,
 459                                         Error **errp)
 460 {
 461     if (qemu_in_coroutine()) {
 462         return bdrv_co_remove_persistent_dirty_bitmap(bs, name, errp);
 463     } else {
 464         Coroutine *co;
 465         BdrvRemovePersistentDirtyBitmapCo s = {
 466             .bs = bs,
 467             .name = name,
 468             .errp = errp,
 469             .ret = -EINPROGRESS,
 470         };
 471
 472         co = qemu_coroutine_create(bdrv_co_remove_persistent_dirty_bitmap_entry,
 473                                    &s);
 474         bdrv_coroutine_enter(bs, co);
 475         BDRV_POLL_WHILE(bs, s.ret == -EINPROGRESS);
 476
 477         return s.ret;
 478     }
 479 }
 480
 481 bool
 482 bdrv_supports_persistent_dirty_bitmap(BlockDriverState *bs)
 483 {
 484     if (bs->drv && bs->drv->bdrv_supports_persistent_dirty_bitmap) {
 485         return bs->drv->bdrv_supports_persistent_dirty_bitmap(bs);
 486     }
 487     return false;
 488 }
 489
 490 static bool coroutine_fn
 491 bdrv_co_can_store_new_dirty_bitmap(BlockDriverState *bs, const char *name,
 492                                    uint32_t granularity, Error **errp)
 493 {
 494     BlockDriver *drv = bs->drv;
 495
 496     if (!drv) {
 497         error_setg_errno(errp, ENOMEDIUM,
 498                          "Can't store persistent bitmaps to %s",
 499                          bdrv_get_device_or_node_name(bs));
 500         return false;
 501     }
 502
 503     if (!drv->bdrv_co_can_store_new_dirty_bitmap) {
 504         error_setg_errno(errp, ENOTSUP,
 505                          "Can't store persistent bitmaps to %s",
 506                          bdrv_get_device_or_node_name(bs));
 507         return false;
 508     }
 509
 510     return drv->bdrv_co_can_store_new_dirty_bitmap(bs, name, granularity, errp);
 511 }
 512
 513 typedef struct BdrvCanStoreNewDirtyBitmapCo {
 514     BlockDriverState *bs;
 515     const char *name;
 516     uint32_t granularity;
 517     Error **errp;
 518     bool ret;
 519
 520     bool in_progress;
 521 } BdrvCanStoreNewDirtyBitmapCo;
 522
 523 static void coroutine_fn bdrv_co_can_store_new_dirty_bitmap_entry(void *opaque)
 524 {
 525     BdrvCanStoreNewDirtyBitmapCo *s = opaque;
 526
 527     s->ret = bdrv_co_can_store_new_dirty_bitmap(s->bs, s->name, s->granularity,
 528                                                 s->errp);
 529     s->in_progress = false;
 530     aio_wait_kick();
 531 }
 532
 533 bool bdrv_can_store_new_dirty_bitmap(BlockDriverState *bs, const char *name,
 534                                      uint32_t granularity, Error **errp)
 535 {
 536     if (qemu_in_coroutine()) {
 537         return bdrv_co_can_store_new_dirty_bitmap(bs, name, granularity, errp);
 538     } else {
 539         Coroutine *co;
 540         BdrvCanStoreNewDirtyBitmapCo s = {
 541             .bs = bs,
 542             .name = name,
 543             .granularity = granularity,
 544             .errp = errp,
 545             .in_progress = true,
 546         };
 547
 548         co = qemu_coroutine_create(bdrv_co_can_store_new_dirty_bitmap_entry,
 549                                    &s);
 550         bdrv_coroutine_enter(bs, co);
 551         BDRV_POLL_WHILE(bs, s.in_progress);
 552
 553         return s.ret;
 554     }
 555 }
 556
 557 void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
 558 {
 559     bdrv_dirty_bitmaps_lock(bitmap->bs);
 560     bitmap->disabled = true;
 561     bdrv_dirty_bitmaps_unlock(bitmap->bs);
 562 }
 563
 564 void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
 565 {
 566     bdrv_dirty_bitmaps_lock(bitmap->bs);
 567     bdrv_enable_dirty_bitmap_locked(bitmap);
 568     bdrv_dirty_bitmaps_unlock(bitmap->bs);
 569 }
 570
 571 BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs)
 572 {
 573     BdrvDirtyBitmap *bm;
 574     BlockDirtyInfoList *list = NULL;
 575     BlockDirtyInfoList **tail = &list;
 576
 577     bdrv_dirty_bitmaps_lock(bs);
 578     QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
 579         BlockDirtyInfo *info = g_new0(BlockDirtyInfo, 1);
 580
 581         info->count = bdrv_get_dirty_count(bm);
 582         info->granularity = bdrv_dirty_bitmap_granularity(bm);
 583         info->has_name = !!bm->name;
 584         info->name = g_strdup(bm->name);
 585         info->status = bdrv_dirty_bitmap_status(bm);
 586         info->recording = bdrv_dirty_bitmap_recording(bm);
 587         info->busy = bdrv_dirty_bitmap_busy(bm);
 588         info->persistent = bm->persistent;
 589         info->has_inconsistent = bm->inconsistent;
 590         info->inconsistent = bm->inconsistent;
 591         QAPI_LIST_APPEND(tail, info);
 592     }
 593     bdrv_dirty_bitmaps_unlock(bs);
 594
 595     return list;
 596 }
 597
 598 /* Called within bdrv_dirty_bitmap_lock..unlock */
 599 bool bdrv_dirty_bitmap_get_locked(BdrvDirtyBitmap *bitmap, int64_t offset)
 600 {
 601     return hbitmap_get(bitmap->bitmap, offset);
 602 }
 603
 604 bool bdrv_dirty_bitmap_get(BdrvDirtyBitmap *bitmap, int64_t offset)
 605 {
 606     bool ret;
 607     bdrv_dirty_bitmaps_lock(bitmap->bs);
 608     ret = bdrv_dirty_bitmap_get_locked(bitmap, offset);
 609     bdrv_dirty_bitmaps_unlock(bitmap->bs);
 610
 611     return ret;
 612 }
 613
 614 /**
 615  * Chooses a default granularity based on the existing cluster size,
 616  * but clamped between [4K, 64K]. Defaults to 64K in the case that there
 617  * is no cluster size information available.
 618  */
 619 uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState *bs)
 620 {
 621     BlockDriverInfo bdi;
 622     uint32_t granularity;
 623
 624     if (bdrv_get_info(bs, &bdi) >= 0 && bdi.cluster_size > 0) {
 625         granularity = MAX(4096, bdi.cluster_size);
 626         granularity = MIN(65536, granularity);
 627     } else {
 628         granularity = 65536;
 629     }
 630
 631     return granularity;
 632 }
 633
 634 uint32_t bdrv_dirty_bitmap_granularity(const BdrvDirtyBitmap *bitmap)
 635 {
 636     return 1U << hbitmap_granularity(bitmap->bitmap);
 637 }
 638
 639 BdrvDirtyBitmapIter *bdrv_dirty_iter_new(BdrvDirtyBitmap *bitmap)
 640 {
 641     BdrvDirtyBitmapIter *iter = g_new(BdrvDirtyBitmapIter, 1);
 642     hbitmap_iter_init(&iter->hbi, bitmap->bitmap, 0);
 643     iter->bitmap = bitmap;
 644     bitmap->active_iterators++;
 645     return iter;
 646 }
 647
 648 void bdrv_dirty_iter_free(BdrvDirtyBitmapIter *iter)
 649 {
 650     if (!iter) {
 651         return;
 652     }
 653     assert(iter->bitmap->active_iterators > 0);
 654     iter->bitmap->active_iterators--;
 655     g_free(iter);
 656 }
 657
 658 int64_t bdrv_dirty_iter_next(BdrvDirtyBitmapIter *iter)
 659 {
 660     return hbitmap_iter_next(&iter->hbi);
 661 }
 662
 663 /* Called within bdrv_dirty_bitmap_lock..unlock */
 664 void bdrv_set_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap,
 665                                   int64_t offset, int64_t bytes)
 666 {
 667     assert(!bdrv_dirty_bitmap_readonly(bitmap));
 668     hbitmap_set(bitmap->bitmap, offset, bytes);
 669 }
 670
 671 void bdrv_set_dirty_bitmap(BdrvDirtyBitmap *bitmap,
 672                            int64_t offset, int64_t bytes)
 673 {
 674     bdrv_dirty_bitmaps_lock(bitmap->bs);
 675     bdrv_set_dirty_bitmap_locked(bitmap, offset, bytes);
 676     bdrv_dirty_bitmaps_unlock(bitmap->bs);
 677 }
 678
 679 /* Called within bdrv_dirty_bitmap_lock..unlock */
 680 void bdrv_reset_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap,
 681                                     int64_t offset, int64_t bytes)
 682 {
 683     assert(!bdrv_dirty_bitmap_readonly(bitmap));
 684     hbitmap_reset(bitmap->bitmap, offset, bytes);
 685 }
 686
 687 void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap *bitmap,
 688                              int64_t offset, int64_t bytes)
 689 {
 690     bdrv_dirty_bitmaps_lock(bitmap->bs);
 691     bdrv_reset_dirty_bitmap_locked(bitmap, offset, bytes);
 692     bdrv_dirty_bitmaps_unlock(bitmap->bs);
 693 }
 694
 695 void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap **out)
 696 {
 697     assert(!bdrv_dirty_bitmap_readonly(bitmap));
 698     bdrv_dirty_bitmaps_lock(bitmap->bs);
 699     if (!out) {
 700         hbitmap_reset_all(bitmap->bitmap);
 701     } else {
 702         HBitmap *backup = bitmap->bitmap;
 703         bitmap->bitmap = hbitmap_alloc(bitmap->size,
 704                                        hbitmap_granularity(backup));
 705         *out = backup;
 706     }
 707     bdrv_dirty_bitmaps_unlock(bitmap->bs);
 708 }
 709
 710 void bdrv_restore_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap *backup)
 711 {
 712     HBitmap *tmp = bitmap->bitmap;
 713     assert(!bdrv_dirty_bitmap_readonly(bitmap));
 714     bitmap->bitmap = backup;
 715     hbitmap_free(tmp);
 716 }
 717
 718 uint64_t bdrv_dirty_bitmap_serialization_size(const BdrvDirtyBitmap *bitmap,
 719                                               uint64_t offset, uint64_t bytes)
 720 {
 721     return hbitmap_serialization_size(bitmap->bitmap, offset, bytes);
 722 }
 723
 724 uint64_t bdrv_dirty_bitmap_serialization_align(const BdrvDirtyBitmap *bitmap)
 725 {
 726     return hbitmap_serialization_align(bitmap->bitmap);
 727 }
 728
 729 /* Return the disk size covered by a chunk of serialized bitmap data. */
 730 uint64_t bdrv_dirty_bitmap_serialization_coverage(int serialized_chunk_size,
 731                                                   const BdrvDirtyBitmap *bitmap)
 732 {
 733     uint64_t granularity = bdrv_dirty_bitmap_granularity(bitmap);
 734     uint64_t limit = granularity * (serialized_chunk_size << 3);
 735
 736     assert(QEMU_IS_ALIGNED(limit,
 737                            bdrv_dirty_bitmap_serialization_align(bitmap)));
 738     return limit;
 739 }
 740
 741
 742 void bdrv_dirty_bitmap_serialize_part(const BdrvDirtyBitmap *bitmap,
 743                                       uint8_t *buf, uint64_t offset,
 744                                       uint64_t bytes)
 745 {
 746     hbitmap_serialize_part(bitmap->bitmap, buf, offset, bytes);
 747 }
 748
 749 void bdrv_dirty_bitmap_deserialize_part(BdrvDirtyBitmap *bitmap,
 750                                         uint8_t *buf, uint64_t offset,
 751                                         uint64_t bytes, bool finish)
 752 {
 753     hbitmap_deserialize_part(bitmap->bitmap, buf, offset, bytes, finish);
 754 }
 755
 756 void bdrv_dirty_bitmap_deserialize_zeroes(BdrvDirtyBitmap *bitmap,
 757                                           uint64_t offset, uint64_t bytes,
 758                                           bool finish)
 759 {
 760     hbitmap_deserialize_zeroes(bitmap->bitmap, offset, bytes, finish);
 761 }
 762
 763 void bdrv_dirty_bitmap_deserialize_ones(BdrvDirtyBitmap *bitmap,
 764                                         uint64_t offset, uint64_t bytes,
 765                                         bool finish)
 766 {
 767     hbitmap_deserialize_ones(bitmap->bitmap, offset, bytes, finish);
 768 }
 769
 770 void bdrv_dirty_bitmap_deserialize_finish(BdrvDirtyBitmap *bitmap)
 771 {
 772     hbitmap_deserialize_finish(bitmap->bitmap);
 773 }
 774
 775 void bdrv_set_dirty(BlockDriverState *bs, int64_t offset, int64_t bytes)
 776 {
 777     BdrvDirtyBitmap *bitmap;
 778
 779     if (QLIST_EMPTY(&bs->dirty_bitmaps)) {
 780         return;
 781     }
 782
 783     bdrv_dirty_bitmaps_lock(bs);
 784     QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
 785         if (!bdrv_dirty_bitmap_enabled(bitmap)) {
 786             continue;
 787         }
 788         assert(!bdrv_dirty_bitmap_readonly(bitmap));
 789         hbitmap_set(bitmap->bitmap, offset, bytes);
 790     }
 791     bdrv_dirty_bitmaps_unlock(bs);
 792 }
 793
 794 /**
 795  * Advance a BdrvDirtyBitmapIter to an arbitrary offset.
 796  */
 797 void bdrv_set_dirty_iter(BdrvDirtyBitmapIter *iter, int64_t offset)
 798 {
 799     hbitmap_iter_init(&iter->hbi, iter->hbi.hb, offset);
 800 }
 801
 802 int64_t bdrv_get_dirty_count(BdrvDirtyBitmap *bitmap)
 803 {
 804     return hbitmap_count(bitmap->bitmap);
 805 }
 806
 807 bool bdrv_dirty_bitmap_readonly(const BdrvDirtyBitmap *bitmap)
 808 {
 809     return bitmap->readonly;
 810 }
 811
 812 /* Called with BQL taken. */
 813 void bdrv_dirty_bitmap_set_readonly(BdrvDirtyBitmap *bitmap, bool value)
 814 {
 815     bdrv_dirty_bitmaps_lock(bitmap->bs);
 816     bitmap->readonly = value;
 817     bdrv_dirty_bitmaps_unlock(bitmap->bs);
 818 }
 819
 820 bool bdrv_has_readonly_bitmaps(BlockDriverState *bs)
 821 {
 822     BdrvDirtyBitmap *bm;
 823     QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
 824         if (bm->readonly) {
 825             return true;
 826         }
 827     }
 828
 829     return false;
 830 }
 831
 832 bool bdrv_has_named_bitmaps(BlockDriverState *bs)
 833 {
 834     BdrvDirtyBitmap *bm;
 835
 836     QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
 837         if (bdrv_dirty_bitmap_name(bm)) {
 838             return true;
 839         }
 840     }
 841
 842     return false;
 843 }
 844
 845 /* Called with BQL taken. */
 846 void bdrv_dirty_bitmap_set_persistence(BdrvDirtyBitmap *bitmap, bool persistent)
 847 {
 848     bdrv_dirty_bitmaps_lock(bitmap->bs);
 849     bitmap->persistent = persistent;
 850     bdrv_dirty_bitmaps_unlock(bitmap->bs);
 851 }
 852
 853 /* Called with BQL taken. */
 854 void bdrv_dirty_bitmap_set_inconsistent(BdrvDirtyBitmap *bitmap)
 855 {
 856     bdrv_dirty_bitmaps_lock(bitmap->bs);
 857     assert(bitmap->persistent == true);
 858     bitmap->inconsistent = true;
 859     bitmap->disabled = true;
 860     bdrv_dirty_bitmaps_unlock(bitmap->bs);
 861 }
 862
 863 /* Called with BQL taken. */
 864 void bdrv_dirty_bitmap_skip_store(BdrvDirtyBitmap *bitmap, bool skip)
 865 {
 866     bdrv_dirty_bitmaps_lock(bitmap->bs);
 867     bitmap->skip_store = skip;
 868     bdrv_dirty_bitmaps_unlock(bitmap->bs);
 869 }
 870
 871 bool bdrv_dirty_bitmap_get_persistence(BdrvDirtyBitmap *bitmap)
 872 {
 873     return bitmap->persistent && !bitmap->skip_store;
 874 }
 875
 876 bool bdrv_dirty_bitmap_inconsistent(const BdrvDirtyBitmap *bitmap)
 877 {
 878     return bitmap->inconsistent;
 879 }
 880
 881 BdrvDirtyBitmap *bdrv_dirty_bitmap_first(BlockDriverState *bs)
 882 {
 883     return QLIST_FIRST(&bs->dirty_bitmaps);
 884 }
 885
 886 BdrvDirtyBitmap *bdrv_dirty_bitmap_next(BdrvDirtyBitmap *bitmap)
 887 {
 888     return QLIST_NEXT(bitmap, list);
 889 }
 890
 891 char *bdrv_dirty_bitmap_sha256(const BdrvDirtyBitmap *bitmap, Error **errp)
 892 {
 893     return hbitmap_sha256(bitmap->bitmap, errp);
 894 }
 895
 896 int64_t bdrv_dirty_bitmap_next_dirty(BdrvDirtyBitmap *bitmap, int64_t offset,
 897                                      int64_t bytes)
 898 {
 899     return hbitmap_next_dirty(bitmap->bitmap, offset, bytes);
 900 }
 901
 902 int64_t bdrv_dirty_bitmap_next_zero(BdrvDirtyBitmap *bitmap, int64_t offset,
 903                                     int64_t bytes)
 904 {
 905     return hbitmap_next_zero(bitmap->bitmap, offset, bytes);
 906 }
 907
 908 bool bdrv_dirty_bitmap_next_dirty_area(BdrvDirtyBitmap *bitmap,
 909         int64_t start, int64_t end, int64_t max_dirty_count,
 910         int64_t *dirty_start, int64_t *dirty_count)
 911 {
 912     return hbitmap_next_dirty_area(bitmap->bitmap, start, end, max_dirty_count,
 913                                    dirty_start, dirty_count);
 914 }
 915
 916 /**
 917  * bdrv_merge_dirty_bitmap: merge src into dest.
 918  * Ensures permissions on bitmaps are reasonable; use for public API.
 919  *
 920  * @backup: If provided, make a copy of dest here prior to merge.
 921  */
 922 void bdrv_merge_dirty_bitmap(BdrvDirtyBitmap *dest, const BdrvDirtyBitmap *src,
 923                              HBitmap **backup, Error **errp)
 924 {
 925     bool ret;
 926
 927     bdrv_dirty_bitmaps_lock(dest->bs);
 928     if (src->bs != dest->bs) {
 929         bdrv_dirty_bitmaps_lock(src->bs);
 930     }
 931
 932     if (bdrv_dirty_bitmap_check(dest, BDRV_BITMAP_DEFAULT, errp)) {
 933         goto out;
 934     }
 935
 936     if (bdrv_dirty_bitmap_check(src, BDRV_BITMAP_ALLOW_RO, errp)) {
 937         goto out;
 938     }
 939
 940     if (!hbitmap_can_merge(dest->bitmap, src->bitmap)) {
 941         error_setg(errp, "Bitmaps are incompatible and can't be merged");
 942         goto out;
 943     }
 944
 945     ret = bdrv_dirty_bitmap_merge_internal(dest, src, backup, false);
 946     assert(ret);
 947
 948 out:
 949     bdrv_dirty_bitmaps_unlock(dest->bs);
 950     if (src->bs != dest->bs) {
 951         bdrv_dirty_bitmaps_unlock(src->bs);
 952     }
 953 }
 954
 955 /**
 956  * bdrv_dirty_bitmap_merge_internal: merge src into dest.
 957  * Does NOT check bitmap permissions; not suitable for use as public API.
 958  *
 959  * @backup: If provided, make a copy of dest here prior to merge.
 960  * @lock: If true, lock and unlock bitmaps on the way in/out.
 961  * returns true if the merge succeeded; false if unattempted.
 962  */
 963 bool bdrv_dirty_bitmap_merge_internal(BdrvDirtyBitmap *dest,
 964                                       const BdrvDirtyBitmap *src,
 965                                       HBitmap **backup,
 966                                       bool lock)
 967 {
 968     bool ret;
 969
 970     assert(!bdrv_dirty_bitmap_readonly(dest));
 971     assert(!bdrv_dirty_bitmap_inconsistent(dest));
 972     assert(!bdrv_dirty_bitmap_inconsistent(src));
 973
 974     if (lock) {
 975         bdrv_dirty_bitmaps_lock(dest->bs);
 976         if (src->bs != dest->bs) {
 977             bdrv_dirty_bitmaps_lock(src->bs);
 978         }
 979     }
 980
 981     if (backup) {
 982         *backup = dest->bitmap;
 983         dest->bitmap = hbitmap_alloc(dest->size, hbitmap_granularity(*backup));
 984         ret = hbitmap_merge(*backup, src->bitmap, dest->bitmap);
 985     } else {
 986         ret = hbitmap_merge(dest->bitmap, src->bitmap, dest->bitmap);
 987     }
 988
 989     if (lock) {
 990         bdrv_dirty_bitmaps_unlock(dest->bs);
 991         if (src->bs != dest->bs) {
 992             bdrv_dirty_bitmaps_unlock(src->bs);
 993         }
 994     }
 995
 996     return ret;
 997 }