From 9d75983943f6510a804b2b9c48efa1eb3dcb41a2 Mon Sep 17 00:00:00 2001

From: John Snow <jsnow@redhat.com>

Date: Tue, 20 Nov 2018 18:18:06 +0000

Subject: [PATCH 12/35] block: simplify code around releasing bitmaps

RH-Author: John Snow <jsnow@redhat.com>

Message-id: <20181120181828.15132-3-jsnow@redhat.com>

Patchwork-id: 83053

O-Subject: [RHEL8/rhel qemu-kvm PATCH 02/24] block: simplify code around releasing bitmaps

Bugzilla: 1518989

RH-Acked-by: Laurent Vivier <lvivier@redhat.com>

RH-Acked-by: Max Reitz <mreitz@redhat.com>

RH-Acked-by: Stefan Hajnoczi <stefanha@redhat.com>

From: Paolo Bonzini <pbonzini@redhat.com>

QLIST_REMOVE does not require walking the list, and once the "bitmap"

argument is removed from bdrv_do_release_matching_dirty_bitmap_locked

the code simplifies a lot and it is worth inlining everything in the

callers of bdrv_do_release_matching_dirty_bitmap.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>

Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

Reviewed-by: John Snow <jsnow@redhat.com>

Message-id: 20180326104037.6894-1-pbonzini@redhat.com

Signed-off-by: John Snow <jsnow@redhat.com>

(cherry picked from commit b133c27f5dc59969574b0715e5837d32c99caa86)

Signed-off-by: John Snow <jsnow@redhat.com>

Signed-off-by: Danilo C. L. de Paula <ddepaula@redhat.com>

---

 block/dirty-bitmap.c | 84 ++++++++++++++++++++--------------------------------

 1 file changed, 32 insertions(+), 52 deletions(-)

diff --git a/block/dirty-bitmap.c b/block/dirty-bitmap.c

index 634f143..dac8d74 100644

--- a/block/dirty-bitmap.c

+++ b/block/dirty-bitmap.c

@@ -256,49 +256,16 @@ void bdrv_dirty_bitmap_enable_successor(BdrvDirtyBitmap *bitmap)

     qemu_mutex_unlock(bitmap->mutex);

 }

-/* Called within bdrv_dirty_bitmap_lock..unlock */

-static void bdrv_do_release_matching_dirty_bitmap_locked(

-    BlockDriverState *bs, BdrvDirtyBitmap *bitmap,

-    bool (*cond)(BdrvDirtyBitmap *bitmap))

+/* Called within bdrv_dirty_bitmap_lock..unlock and with BQL taken.  */

+static void bdrv_release_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap)

 {

-    BdrvDirtyBitmap *bm, *next;

-

-    QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) {

-        if ((!bitmap || bm == bitmap) && (!cond || cond(bm))) {

-            assert(!bm->active_iterators);

-            assert(!bdrv_dirty_bitmap_frozen(bm));

-            assert(!bm->meta);

-            QLIST_REMOVE(bm, list);

-            hbitmap_free(bm->bitmap);

-            g_free(bm->name);

-            g_free(bm);

-

-            if (bitmap) {

-                return;

-            }

-        }

-    }

-

-    if (bitmap) {

-        abort();

-    }

-}

-

-/* Called with BQL taken.  */

-static void bdrv_do_release_matching_dirty_bitmap(

-    BlockDriverState *bs, BdrvDirtyBitmap *bitmap,

-    bool (*cond)(BdrvDirtyBitmap *bitmap))

-{

-    bdrv_dirty_bitmaps_lock(bs);

-    bdrv_do_release_matching_dirty_bitmap_locked(bs, bitmap, cond);

-    bdrv_dirty_bitmaps_unlock(bs);

-}

-

-/* Called within bdrv_dirty_bitmap_lock..unlock */

-static void bdrv_release_dirty_bitmap_locked(BlockDriverState *bs,

-                                             BdrvDirtyBitmap *bitmap)

-{

-    bdrv_do_release_matching_dirty_bitmap_locked(bs, bitmap, NULL);

+    assert(!bitmap->active_iterators);

+    assert(!bdrv_dirty_bitmap_frozen(bitmap));

+    assert(!bitmap->meta);

+    QLIST_REMOVE(bitmap, list);

+    hbitmap_free(bitmap->bitmap);

+    g_free(bitmap->name);

+    g_free(bitmap);

 }

 /**

@@ -351,7 +318,7 @@ BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap_locked(BlockDriverState *bs,

         error_setg(errp, "Merging of parent and successor bitmap failed");

         return NULL;

     }

-    bdrv_release_dirty_bitmap_locked(bs, successor);

+    bdrv_release_dirty_bitmap_locked(successor);

     parent->successor = NULL;

     return parent;

@@ -389,15 +356,12 @@ void bdrv_dirty_bitmap_truncate(BlockDriverState *bs, int64_t bytes)

     bdrv_dirty_bitmaps_unlock(bs);

 }

-static bool bdrv_dirty_bitmap_has_name(BdrvDirtyBitmap *bitmap)

-{

-    return !!bdrv_dirty_bitmap_name(bitmap);

-}

-

 /* Called with BQL taken.  */

 void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)

 {

-    bdrv_do_release_matching_dirty_bitmap(bs, bitmap, NULL);

+    bdrv_dirty_bitmaps_lock(bs);

+    bdrv_release_dirty_bitmap_locked(bitmap);

+    bdrv_dirty_bitmaps_unlock(bs);

 }

 /**

@@ -408,7 +372,15 @@ void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)

  */

 void bdrv_release_named_dirty_bitmaps(BlockDriverState *bs)

 {

-    bdrv_do_release_matching_dirty_bitmap(bs, NULL, bdrv_dirty_bitmap_has_name);

+    BdrvDirtyBitmap *bm, *next;

+

+    bdrv_dirty_bitmaps_lock(bs);

+    QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) {

+        if (bdrv_dirty_bitmap_name(bm)) {

+            bdrv_release_dirty_bitmap_locked(bm);

+        }

+    }

+    bdrv_dirty_bitmaps_unlock(bs);

 }

 /**

@@ -416,11 +388,19 @@ void bdrv_release_named_dirty_bitmaps(BlockDriverState *bs)

  * bdrv_inactivate_recurse()).

  * There must not be any frozen bitmaps attached.

  * This function does not remove persistent bitmaps from the storage.

+ * Called with BQL taken.

  */

 void bdrv_release_persistent_dirty_bitmaps(BlockDriverState *bs)

 {

-    bdrv_do_release_matching_dirty_bitmap(bs, NULL,

-                                          bdrv_dirty_bitmap_get_persistance);

+    BdrvDirtyBitmap *bm, *next;

+

+    bdrv_dirty_bitmaps_lock(bs);

+    QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) {

+        if (bdrv_dirty_bitmap_get_persistance(bm)) {

+            bdrv_release_dirty_bitmap_locked(bm);

+        }

+    }

+    bdrv_dirty_bitmaps_unlock(bs);

 }

 /**

-- 

1.8.3.1