WIP: Remove hide() API

block.c

@@ -5316,7 +5316,7 @@ static void coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs,
     for (bm = bdrv_dirty_bitmap_next(bs, NULL); bm;
          bm = bdrv_dirty_bitmap_next(bs, bm))
     {
-        bdrv_dirty_bitmap_set_migration(bm, false);
+        bdrv_dirty_bitmap_squelch_persistence(bm, false);
     }
 
     ret = refresh_total_sectors(bs, bs->total_sectors);

block/dirty-bitmap.c

@@ -34,10 +34,6 @@ struct BdrvDirtyBitmap {
     bool busy;                  /* Bitmap is busy, it can't be used via QMP */
     BdrvDirtyBitmap *successor; /* Anonymous child, if any. */
     char *name;                 /* Optional non-empty unique ID */
-    char *hidden_name;          /* Backup of @name for removal transaction
-                                   action. Used for hide/unhide API. */
-    bool hidden_persistent;     /* Backup of @persistent for removal transaction
-                                   action. */
     int64_t size;               /* Size of the bitmap, in bytes */
     bool disabled;              /* Bitmap is disabled. It ignores all writes to
                                    the device */
@@ -52,10 +48,9 @@ struct BdrvDirtyBitmap {
     bool inconsistent;          /* bitmap is persistent, but inconsistent.
                                    It cannot be used at all in any way, except
                                    a QMP user can remove it. */
-    bool migration;             /* Bitmap is selected for migration, it should
-                                   not be stored on the next inactivation
-                                   (persistent flag doesn't matter until next
-                                   invalidation).*/
+    bool squelch_persistence;   /* We are either migrating or deleting this
+                                 * bitmap; it should not be stored on the next
+                                 * inactivation. */
     QLIST_ENTRY(BdrvDirtyBitmap) list;
 };
 
@@ -761,16 +756,17 @@ void bdrv_dirty_bitmap_set_inconsistent(BdrvDirtyBitmap *bitmap)
 }
 
 /* Called with BQL taken. */
-void bdrv_dirty_bitmap_set_migration(BdrvDirtyBitmap *bitmap, bool migration)
+void bdrv_dirty_bitmap_squelch_persistence(BdrvDirtyBitmap *bitmap,
+                                           bool squelch)
 {
     qemu_mutex_lock(bitmap->mutex);
-    bitmap->migration = migration;
+    bitmap->squelch_persistence = squelch;
     qemu_mutex_unlock(bitmap->mutex);
 }
 
 bool bdrv_dirty_bitmap_get_persistence(BdrvDirtyBitmap *bitmap)
 {
-    return bitmap->persistent && !bitmap->migration;
+    return bitmap->persistent && !bitmap->squelch_persistence;
 }
 
 bool bdrv_dirty_bitmap_inconsistent(const BdrvDirtyBitmap *bitmap)
@@ -782,7 +778,7 @@ bool bdrv_has_changed_persistent_bitmaps(BlockDriverState *bs)
 {
     BdrvDirtyBitmap *bm;
     QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
-        if (bm->persistent && !bm->readonly && !bm->migration) {
+        if (bm->persistent && !bm->readonly && !bm->squelch_persistence) {
             return true;
         }
     }
@@ -852,25 +848,3 @@ void bdrv_merge_dirty_bitmap(BdrvDirtyBitmap *dest, const BdrvDirtyBitmap *src,
         qemu_mutex_unlock(src->mutex);
     }
 }
-
-void bdrv_dirty_bitmap_hide(BdrvDirtyBitmap *bitmap)
-{
-    qemu_mutex_lock(bitmap->mutex);
-    assert(!bitmap->hidden_name);
-    bitmap->hidden_name = bitmap->name;
-    bitmap->hidden_persistent = bitmap->persistent;
-    bitmap->name = NULL;
-    bitmap->persistent = false;
-    qemu_mutex_unlock(bitmap->mutex);
-}
-
-void bdrv_dirty_bitmap_unhide(BdrvDirtyBitmap *bitmap)
-{
-    qemu_mutex_lock(bitmap->mutex);
-    assert(!bitmap->name);
-    bitmap->name = bitmap->hidden_name;
-    bitmap->persistent = bitmap->hidden_persistent;
-    bitmap->hidden_name = NULL;
-    bitmap->hidden_persistent = false;
-    qemu_mutex_unlock(bitmap->mutex);
-}

blockdev.c

@@ -2154,7 +2154,8 @@ static void block_dirty_bitmap_remove_prepare(BlkActionState *common,
     state->bitmap = do_block_dirty_bitmap_remove(action->node, action->name,
                                                  false, &state->bs, errp);
     if (state->bitmap) {
-        bdrv_dirty_bitmap_hide(state->bitmap);
+        bdrv_dirty_bitmap_squelch_persistence(state->bitmap, true);
+        bdrv_dirty_bitmap_set_busy(state->bitmap, true);
     }
 }
 
@@ -2163,14 +2164,18 @@ static void block_dirty_bitmap_remove_abort(BlkActionState *common)
     BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
                                              common, common);
 
-    bdrv_dirty_bitmap_unhide(state->bitmap);
+    if (state->bitmap) {
+        bdrv_dirty_bitmap_squelch_persistence(state->bitmap, false);
+        bdrv_dirty_bitmap_set_busy(state->bitmap, false);
+    }
 }
 
 static void block_dirty_bitmap_remove_commit(BlkActionState *common)
 {
     BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
                                              common, common);
 
+    bdrv_dirty_bitmap_set_busy(state->bitmap, false);
     bdrv_release_dirty_bitmap(state->bs, state->bitmap);
 }
 

include/block/dirty-bitmap.h

@@ -83,7 +83,8 @@ void bdrv_dirty_bitmap_set_inconsistent(BdrvDirtyBitmap *bitmap);
 void bdrv_dirty_bitmap_set_busy(BdrvDirtyBitmap *bitmap, bool busy);
 void bdrv_merge_dirty_bitmap(BdrvDirtyBitmap *dest, const BdrvDirtyBitmap *src,
                              HBitmap **backup, Error **errp);
-void bdrv_dirty_bitmap_set_migration(BdrvDirtyBitmap *bitmap, bool migration);
+void bdrv_dirty_bitmap_squelch_persistence(BdrvDirtyBitmap *bitmap,
+                                           bool squelch);
 
 /* Functions that require manual locking.  */
 void bdrv_dirty_bitmap_lock(BdrvDirtyBitmap *bitmap);
@@ -115,7 +116,5 @@ bool bdrv_dirty_bitmap_next_dirty_area(BdrvDirtyBitmap *bitmap,
 BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap_locked(BlockDriverState *bs,
                                                   BdrvDirtyBitmap *bitmap,
                                                   Error **errp);
-void bdrv_dirty_bitmap_hide(BdrvDirtyBitmap *bitmap);
-void bdrv_dirty_bitmap_unhide(BdrvDirtyBitmap *bitmap);
 
 #endif

migration/block-dirty-bitmap.c

@@ -326,7 +326,7 @@ static int init_dirty_bitmap_migration(void)
 
     /* unset migration flags here, to not roll back it */
     QSIMPLEQ_FOREACH(dbms, &dirty_bitmap_mig_state.dbms_list, entry) {
-        bdrv_dirty_bitmap_set_migration(dbms->bitmap, true);
+        bdrv_dirty_bitmap_squelch_persistence(dbms->bitmap, true);
     }
 
     if (QSIMPLEQ_EMPTY(&dirty_bitmap_mig_state.dbms_list)) {