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 **plist = &list;
 576
 577     bdrv_dirty_bitmaps_lock(bs);
 578     QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
 579         BlockDirtyInfo *info = g_new0(BlockDirtyInfo, 1);
 580         BlockDirtyInfoList *entry = g_new0(BlockDirtyInfoList, 1);
 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         entry->value = info;
 592         *plist = entry;
 593         plist = &entry->next;
 594     }
 595     bdrv_dirty_bitmaps_unlock(bs);
 596
 597     return list;
 598 }
 599
 600 /* Called within bdrv_dirty_bitmap_lock..unlock */
 601 bool bdrv_dirty_bitmap_get_locked(BdrvDirtyBitmap *bitmap, int64_t offset)
 602 {
 603     return hbitmap_get(bitmap->bitmap, offset);
 604 }
 605
 606 bool bdrv_dirty_bitmap_get(BdrvDirtyBitmap *bitmap, int64_t offset)
 607 {
 608     bool ret;
 609     bdrv_dirty_bitmaps_lock(bitmap->bs);
 610     ret = bdrv_dirty_bitmap_get_locked(bitmap, offset);
 611     bdrv_dirty_bitmaps_unlock(bitmap->bs);
 612
 613     return ret;
 614 }
 615
 616 /**
 617  * Chooses a default granularity based on the existing cluster size,
 618  * but clamped between [4K, 64K]. Defaults to 64K in the case that there
 619  * is no cluster size information available.
 620  */
 621 uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState *bs)
 622 {
 623     BlockDriverInfo bdi;
 624     uint32_t granularity;
 625
 626     if (bdrv_get_info(bs, &bdi) >= 0 && bdi.cluster_size > 0) {
 627         granularity = MAX(4096, bdi.cluster_size);
 628         granularity = MIN(65536, granularity);
 629     } else {
 630         granularity = 65536;
 631     }
 632
 633     return granularity;
 634 }
 635
 636 uint32_t bdrv_dirty_bitmap_granularity(const BdrvDirtyBitmap *bitmap)
 637 {
 638     return 1U << hbitmap_granularity(bitmap->bitmap);
 639 }
 640
 641 BdrvDirtyBitmapIter *bdrv_dirty_iter_new(BdrvDirtyBitmap *bitmap)
 642 {
 643     BdrvDirtyBitmapIter *iter = g_new(BdrvDirtyBitmapIter, 1);
 644     hbitmap_iter_init(&iter->hbi, bitmap->bitmap, 0);
 645     iter->bitmap = bitmap;
 646     bitmap->active_iterators++;
 647     return iter;
 648 }
 649
 650 void bdrv_dirty_iter_free(BdrvDirtyBitmapIter *iter)
 651 {
 652     if (!iter) {
 653         return;
 654     }
 655     assert(iter->bitmap->active_iterators > 0);
 656     iter->bitmap->active_iterators--;
 657     g_free(iter);
 658 }
 659
 660 int64_t bdrv_dirty_iter_next(BdrvDirtyBitmapIter *iter)
 661 {
 662     return hbitmap_iter_next(&iter->hbi);
 663 }
 664
 665 /* Called within bdrv_dirty_bitmap_lock..unlock */
 666 void bdrv_set_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap,
 667                                   int64_t offset, int64_t bytes)
 668 {
 669     assert(!bdrv_dirty_bitmap_readonly(bitmap));
 670     hbitmap_set(bitmap->bitmap, offset, bytes);
 671 }
 672
 673 void bdrv_set_dirty_bitmap(BdrvDirtyBitmap *bitmap,
 674                            int64_t offset, int64_t bytes)
 675 {
 676     bdrv_dirty_bitmaps_lock(bitmap->bs);
 677     bdrv_set_dirty_bitmap_locked(bitmap, offset, bytes);
 678     bdrv_dirty_bitmaps_unlock(bitmap->bs);
 679 }
 680
 681 /* Called within bdrv_dirty_bitmap_lock..unlock */
 682 void bdrv_reset_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap,
 683                                     int64_t offset, int64_t bytes)
 684 {
 685     assert(!bdrv_dirty_bitmap_readonly(bitmap));
 686     hbitmap_reset(bitmap->bitmap, offset, bytes);
 687 }
 688
 689 void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap *bitmap,
 690                              int64_t offset, int64_t bytes)
 691 {
 692     bdrv_dirty_bitmaps_lock(bitmap->bs);
 693     bdrv_reset_dirty_bitmap_locked(bitmap, offset, bytes);
 694     bdrv_dirty_bitmaps_unlock(bitmap->bs);
 695 }
 696
 697 void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap **out)
 698 {
 699     assert(!bdrv_dirty_bitmap_readonly(bitmap));
 700     bdrv_dirty_bitmaps_lock(bitmap->bs);
 701     if (!out) {
 702         hbitmap_reset_all(bitmap->bitmap);
 703     } else {
 704         HBitmap *backup = bitmap->bitmap;
 705         bitmap->bitmap = hbitmap_alloc(bitmap->size,
 706                                        hbitmap_granularity(backup));
 707         *out = backup;
 708     }
 709     bdrv_dirty_bitmaps_unlock(bitmap->bs);
 710 }
 711
 712 void bdrv_restore_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap *backup)
 713 {
 714     HBitmap *tmp = bitmap->bitmap;
 715     assert(!bdrv_dirty_bitmap_readonly(bitmap));
 716     bitmap->bitmap = backup;
 717     hbitmap_free(tmp);
 718 }
 719
 720 uint64_t bdrv_dirty_bitmap_serialization_size(const BdrvDirtyBitmap *bitmap,
 721                                               uint64_t offset, uint64_t bytes)
 722 {
 723     return hbitmap_serialization_size(bitmap->bitmap, offset, bytes);
 724 }
 725
 726 uint64_t bdrv_dirty_bitmap_serialization_align(const BdrvDirtyBitmap *bitmap)
 727 {
 728     return hbitmap_serialization_align(bitmap->bitmap);
 729 }
 730
 731 void bdrv_dirty_bitmap_serialize_part(const BdrvDirtyBitmap *bitmap,
 732                                       uint8_t *buf, uint64_t offset,
 733                                       uint64_t bytes)
 734 {
 735     hbitmap_serialize_part(bitmap->bitmap, buf, offset, bytes);
 736 }
 737
 738 void bdrv_dirty_bitmap_deserialize_part(BdrvDirtyBitmap *bitmap,
 739                                         uint8_t *buf, uint64_t offset,
 740                                         uint64_t bytes, bool finish)
 741 {
 742     hbitmap_deserialize_part(bitmap->bitmap, buf, offset, bytes, finish);
 743 }
 744
 745 void bdrv_dirty_bitmap_deserialize_zeroes(BdrvDirtyBitmap *bitmap,
 746                                           uint64_t offset, uint64_t bytes,
 747                                           bool finish)
 748 {
 749     hbitmap_deserialize_zeroes(bitmap->bitmap, offset, bytes, finish);
 750 }
 751
 752 void bdrv_dirty_bitmap_deserialize_ones(BdrvDirtyBitmap *bitmap,
 753                                         uint64_t offset, uint64_t bytes,
 754                                         bool finish)
 755 {
 756     hbitmap_deserialize_ones(bitmap->bitmap, offset, bytes, finish);
 757 }
 758
 759 void bdrv_dirty_bitmap_deserialize_finish(BdrvDirtyBitmap *bitmap)
 760 {
 761     hbitmap_deserialize_finish(bitmap->bitmap);
 762 }
 763
 764 void bdrv_set_dirty(BlockDriverState *bs, int64_t offset, int64_t bytes)
 765 {
 766     BdrvDirtyBitmap *bitmap;
 767
 768     if (QLIST_EMPTY(&bs->dirty_bitmaps)) {
 769         return;
 770     }
 771
 772     bdrv_dirty_bitmaps_lock(bs);
 773     QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
 774         if (!bdrv_dirty_bitmap_enabled(bitmap)) {
 775             continue;
 776         }
 777         assert(!bdrv_dirty_bitmap_readonly(bitmap));
 778         hbitmap_set(bitmap->bitmap, offset, bytes);
 779     }
 780     bdrv_dirty_bitmaps_unlock(bs);
 781 }
 782
 783 /**
 784  * Advance a BdrvDirtyBitmapIter to an arbitrary offset.
 785  */
 786 void bdrv_set_dirty_iter(BdrvDirtyBitmapIter *iter, int64_t offset)
 787 {
 788     hbitmap_iter_init(&iter->hbi, iter->hbi.hb, offset);
 789 }
 790
 791 int64_t bdrv_get_dirty_count(BdrvDirtyBitmap *bitmap)
 792 {
 793     return hbitmap_count(bitmap->bitmap);
 794 }
 795
 796 bool bdrv_dirty_bitmap_readonly(const BdrvDirtyBitmap *bitmap)
 797 {
 798     return bitmap->readonly;
 799 }
 800
 801 /* Called with BQL taken. */
 802 void bdrv_dirty_bitmap_set_readonly(BdrvDirtyBitmap *bitmap, bool value)
 803 {
 804     bdrv_dirty_bitmaps_lock(bitmap->bs);
 805     bitmap->readonly = value;
 806     bdrv_dirty_bitmaps_unlock(bitmap->bs);
 807 }
 808
 809 bool bdrv_has_readonly_bitmaps(BlockDriverState *bs)
 810 {
 811     BdrvDirtyBitmap *bm;
 812     QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
 813         if (bm->readonly) {
 814             return true;
 815         }
 816     }
 817
 818     return false;
 819 }
 820
 821 bool bdrv_has_named_bitmaps(BlockDriverState *bs)
 822 {
 823     BdrvDirtyBitmap *bm;
 824
 825     QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
 826         if (bdrv_dirty_bitmap_name(bm)) {
 827             return true;
 828         }
 829     }
 830
 831     return false;
 832 }
 833
 834 /* Called with BQL taken. */
 835 void bdrv_dirty_bitmap_set_persistence(BdrvDirtyBitmap *bitmap, bool persistent)
 836 {
 837     bdrv_dirty_bitmaps_lock(bitmap->bs);
 838     bitmap->persistent = persistent;
 839     bdrv_dirty_bitmaps_unlock(bitmap->bs);
 840 }
 841
 842 /* Called with BQL taken. */
 843 void bdrv_dirty_bitmap_set_inconsistent(BdrvDirtyBitmap *bitmap)
 844 {
 845     bdrv_dirty_bitmaps_lock(bitmap->bs);
 846     assert(bitmap->persistent == true);
 847     bitmap->inconsistent = true;
 848     bitmap->disabled = true;
 849     bdrv_dirty_bitmaps_unlock(bitmap->bs);
 850 }
 851
 852 /* Called with BQL taken. */
 853 void bdrv_dirty_bitmap_skip_store(BdrvDirtyBitmap *bitmap, bool skip)
 854 {
 855     bdrv_dirty_bitmaps_lock(bitmap->bs);
 856     bitmap->skip_store = skip;
 857     bdrv_dirty_bitmaps_unlock(bitmap->bs);
 858 }
 859
 860 bool bdrv_dirty_bitmap_get_persistence(BdrvDirtyBitmap *bitmap)
 861 {
 862     return bitmap->persistent && !bitmap->skip_store;
 863 }
 864
 865 bool bdrv_dirty_bitmap_inconsistent(const BdrvDirtyBitmap *bitmap)
 866 {
 867     return bitmap->inconsistent;
 868 }
 869
 870 BdrvDirtyBitmap *bdrv_dirty_bitmap_first(BlockDriverState *bs)
 871 {
 872     return QLIST_FIRST(&bs->dirty_bitmaps);
 873 }
 874
 875 BdrvDirtyBitmap *bdrv_dirty_bitmap_next(BdrvDirtyBitmap *bitmap)
 876 {
 877     return QLIST_NEXT(bitmap, list);
 878 }
 879
 880 char *bdrv_dirty_bitmap_sha256(const BdrvDirtyBitmap *bitmap, Error **errp)
 881 {
 882     return hbitmap_sha256(bitmap->bitmap, errp);
 883 }
 884
 885 int64_t bdrv_dirty_bitmap_next_dirty(BdrvDirtyBitmap *bitmap, int64_t offset,
 886                                      int64_t bytes)
 887 {
 888     return hbitmap_next_dirty(bitmap->bitmap, offset, bytes);
 889 }
 890
 891 int64_t bdrv_dirty_bitmap_next_zero(BdrvDirtyBitmap *bitmap, int64_t offset,
 892                                     int64_t bytes)
 893 {
 894     return hbitmap_next_zero(bitmap->bitmap, offset, bytes);
 895 }
 896
 897 bool bdrv_dirty_bitmap_next_dirty_area(BdrvDirtyBitmap *bitmap,
 898         int64_t start, int64_t end, int64_t max_dirty_count,
 899         int64_t *dirty_start, int64_t *dirty_count)
 900 {
 901     return hbitmap_next_dirty_area(bitmap->bitmap, start, end, max_dirty_count,
 902                                    dirty_start, dirty_count);
 903 }
 904
 905 /**
 906  * bdrv_merge_dirty_bitmap: merge src into dest.
 907  * Ensures permissions on bitmaps are reasonable; use for public API.
 908  *
 909  * @backup: If provided, make a copy of dest here prior to merge.
 910  */
 911 void bdrv_merge_dirty_bitmap(BdrvDirtyBitmap *dest, const BdrvDirtyBitmap *src,
 912                              HBitmap **backup, Error **errp)
 913 {
 914     bool ret;
 915
 916     bdrv_dirty_bitmaps_lock(dest->bs);
 917     if (src->bs != dest->bs) {
 918         bdrv_dirty_bitmaps_lock(src->bs);
 919     }
 920
 921     if (bdrv_dirty_bitmap_check(dest, BDRV_BITMAP_DEFAULT, errp)) {
 922         goto out;
 923     }
 924
 925     if (bdrv_dirty_bitmap_check(src, BDRV_BITMAP_ALLOW_RO, errp)) {
 926         goto out;
 927     }
 928
 929     if (!hbitmap_can_merge(dest->bitmap, src->bitmap)) {
 930         error_setg(errp, "Bitmaps are incompatible and can't be merged");
 931         goto out;
 932     }
 933
 934     ret = bdrv_dirty_bitmap_merge_internal(dest, src, backup, false);
 935     assert(ret);
 936
 937 out:
 938     bdrv_dirty_bitmaps_unlock(dest->bs);
 939     if (src->bs != dest->bs) {
 940         bdrv_dirty_bitmaps_unlock(src->bs);
 941     }
 942 }
 943
 944 /**
 945  * bdrv_dirty_bitmap_merge_internal: merge src into dest.
 946  * Does NOT check bitmap permissions; not suitable for use as public API.
 947  *
 948  * @backup: If provided, make a copy of dest here prior to merge.
 949  * @lock: If true, lock and unlock bitmaps on the way in/out.
 950  * returns true if the merge succeeded; false if unattempted.
 951  */
 952 bool bdrv_dirty_bitmap_merge_internal(BdrvDirtyBitmap *dest,
 953                                       const BdrvDirtyBitmap *src,
 954                                       HBitmap **backup,
 955                                       bool lock)
 956 {
 957     bool ret;
 958
 959     assert(!bdrv_dirty_bitmap_readonly(dest));
 960     assert(!bdrv_dirty_bitmap_inconsistent(dest));
 961     assert(!bdrv_dirty_bitmap_inconsistent(src));
 962
 963     if (lock) {
 964         bdrv_dirty_bitmaps_lock(dest->bs);
 965         if (src->bs != dest->bs) {
 966             bdrv_dirty_bitmaps_lock(src->bs);
 967         }
 968     }
 969
 970     if (backup) {
 971         *backup = dest->bitmap;
 972         dest->bitmap = hbitmap_alloc(dest->size, hbitmap_granularity(*backup));
 973         ret = hbitmap_merge(*backup, src->bitmap, dest->bitmap);
 974     } else {
 975         ret = hbitmap_merge(dest->bitmap, src->bitmap, dest->bitmap);
 976     }
 977
 978     if (lock) {
 979         bdrv_dirty_bitmaps_unlock(dest->bs);
 980         if (src->bs != dest->bs) {
 981             bdrv_dirty_bitmaps_unlock(src->bs);
 982         }
 983     }
 984
 985     return ret;
 986 }