md/md-bitmap: merge md_bitmap_unplug_async() into md_bitmap_unplug()

Add a parameter 'bool sync' to distinguish them, and
md_bitmap_unplug_async() won't be exported anymore, hence
bitmap_operations only need one op to cover them.

Signed-off-by: Yu Kuai <yukuai3@huawei.com>
Link: https://lore.kernel.org/r/20240826074452.1490072-32-yukuai1@huaweicloud.com
Signed-off-by: Song Liu <song@kernel.org>

diff --git a/drivers/md/md-bitmap.c b/drivers/md/md-bitmap.c
index 9fe97f14a71981cf4d16387549ffdaed59d15041..ecfc3a02a9760e12066de09642a521e6d92584e3 100644 (file)
--- a/drivers/md/md-bitmap.c
+++ b/drivers/md/md-bitmap.c
@@ -1026,7 +1026,7 @@ static int md_bitmap_file_test_bit(struct bitmap *bitmap, sector_t block)
 /* this gets called when the md device is ready to unplug its underlying
  * (slave) device queues -- before we let any writes go down, we need to
  * sync the dirty pages of the bitmap file to disk */
-void md_bitmap_unplug(struct bitmap *bitmap)
+static void __bitmap_unplug(struct bitmap *bitmap)
 {
        unsigned long i;
        int dirty, need_write;
@@ -1058,7 +1058,6 @@ void md_bitmap_unplug(struct bitmap *bitmap)
        if (test_bit(BITMAP_WRITE_ERROR, &bitmap->flags))
                md_bitmap_file_kick(bitmap);
 }
-EXPORT_SYMBOL(md_bitmap_unplug);
 
 struct bitmap_unplug_work {
        struct work_struct work;
@@ -1071,11 +1070,11 @@ static void md_bitmap_unplug_fn(struct work_struct *work)
        struct bitmap_unplug_work *unplug_work =
                container_of(work, struct bitmap_unplug_work, work);
 
-       md_bitmap_unplug(unplug_work->bitmap);
+       __bitmap_unplug(unplug_work->bitmap);
        complete(unplug_work->done);
 }
 
-void md_bitmap_unplug_async(struct bitmap *bitmap)
+static void bitmap_unplug_async(struct bitmap *bitmap)
 {
        DECLARE_COMPLETION_ONSTACK(done);
        struct bitmap_unplug_work unplug_work;
@@ -1087,7 +1086,20 @@ void md_bitmap_unplug_async(struct bitmap *bitmap)
        queue_work(md_bitmap_wq, &unplug_work.work);
        wait_for_completion(&done);
 }
-EXPORT_SYMBOL(md_bitmap_unplug_async);
+
+void md_bitmap_unplug(struct mddev *mddev, bool sync)
+{
+       struct bitmap *bitmap = mddev->bitmap;
+
+       if (!bitmap)
+               return;
+
+       if (sync)
+               __bitmap_unplug(bitmap);
+       else
+               bitmap_unplug_async(bitmap);
+}
+EXPORT_SYMBOL_GPL(md_bitmap_unplug);
 
 static void md_bitmap_set_memory_bits(struct bitmap *bitmap, sector_t offset, int needed);
 
@@ -2108,9 +2120,9 @@ int md_bitmap_copy_from_slot(struct mddev *mddev, int slot,
                for (i = 0; i < bitmap->storage.file_pages; i++)
                        if (test_page_attr(bitmap, i, BITMAP_PAGE_PENDING))
                                set_page_attr(bitmap, i, BITMAP_PAGE_NEEDWRITE);
-               md_bitmap_unplug(bitmap);
+               __bitmap_unplug(bitmap);
        }
-       md_bitmap_unplug(mddev->bitmap);
+       __bitmap_unplug(mddev->bitmap);
        *low = lo;
        *high = hi;
        md_bitmap_free(bitmap);
@@ -2351,7 +2363,7 @@ int md_bitmap_resize(struct bitmap *bitmap, sector_t blocks,
        spin_unlock_irq(&bitmap->counts.lock);
 
        if (!init) {
-               md_bitmap_unplug(bitmap);
+               __bitmap_unplug(bitmap);
                bitmap->mddev->pers->quiesce(bitmap->mddev, 0);
        }
        ret = 0;

diff --git a/drivers/md/md-bitmap.h b/drivers/md/md-bitmap.h
index 0953ac73735c7c9c627faa26a3c42384bb2ffa96..ba8ba7e49ef9e2a30956feff8c46c2d0ba00b02a 100644 (file)
--- a/drivers/md/md-bitmap.h
+++ b/drivers/md/md-bitmap.h
@@ -277,8 +277,7 @@ struct bitmap_operations {
 void mddev_set_bitmap_ops(struct mddev *mddev);
 
 /* these are exported */
-void md_bitmap_unplug(struct bitmap *bitmap);
-void md_bitmap_unplug_async(struct bitmap *bitmap);
+void md_bitmap_unplug(struct mddev *mddev, bool sync);
 void md_bitmap_daemon_work(struct mddev *mddev);
 
 int md_bitmap_resize(struct bitmap *bitmap, sector_t blocks,

diff --git a/drivers/md/md.c b/drivers/md/md.c
index f72fa8e872f81127c07744bbe9ff00d5c0422218..b3bc0c76aeb889ea29d3400c6b3c64215a46739f 100644 (file)
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -4715,7 +4715,7 @@ bitmap_store(struct mddev *mddev, const char *buf, size_t len)
                mddev->bitmap_ops->dirty_bits(mddev, chunk, end_chunk);
                buf = skip_spaces(end);
        }
-       md_bitmap_unplug(mddev->bitmap); /* flush the bits to disk */
+       md_bitmap_unplug(mddev, true); /* flush the bits to disk */
 out:
        mddev_unlock(mddev);
        return len;

diff --git a/drivers/md/raid1-10.c b/drivers/md/raid1-10.c
index 2ea1710a3b705e9c68d7ed4a05fcd0bc16e32e2b..45b30f08f3a50013c9ed9b32d91231ebf7f89705 100644 (file)
--- a/drivers/md/raid1-10.c
+++ b/drivers/md/raid1-10.c
@@ -166,12 +166,9 @@ static inline bool raid1_add_bio_to_plug(struct mddev *mddev, struct bio *bio,
  * while current io submission must wait for bitmap io to be done. In order to
  * avoid such deadlock, submit bitmap io asynchronously.
  */
-static inline void raid1_prepare_flush_writes(struct bitmap *bitmap)
+static inline void raid1_prepare_flush_writes(struct mddev *mddev)
 {
-       if (current->bio_list)
-               md_bitmap_unplug_async(bitmap);
-       else
-               md_bitmap_unplug(bitmap);
+       md_bitmap_unplug(mddev, current->bio_list == NULL);
 }
 
 /*

diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 119c9477a453c8b6c1289377895fbfc401674266..f9338756088aa40d5fb7dd28ba06aa173ff5902e 100644 (file)
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -896,7 +896,7 @@ static void wake_up_barrier(struct r1conf *conf)
 static void flush_bio_list(struct r1conf *conf, struct bio *bio)
 {
        /* flush any pending bitmap writes to disk before proceeding w/ I/O */
-       raid1_prepare_flush_writes(conf->mddev->bitmap);
+       raid1_prepare_flush_writes(conf->mddev);
        wake_up_barrier(conf);
 
        while (bio) { /* submit pending writes */

diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 5a7b19f48c45a5b673df79870127ae42d9658f3f..c79f374668dde951f82402b543f44e7df494cb9a 100644 (file)
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -885,7 +885,7 @@ static void flush_pending_writes(struct r10conf *conf)
                __set_current_state(TASK_RUNNING);
 
                blk_start_plug(&plug);
-               raid1_prepare_flush_writes(conf->mddev->bitmap);
+               raid1_prepare_flush_writes(conf->mddev);
                wake_up(&conf->wait_barrier);
 
                while (bio) { /* submit pending writes */
@@ -1101,7 +1101,7 @@ static void raid10_unplug(struct blk_plug_cb *cb, bool from_schedule)
 
        /* we aren't scheduling, so we can do the write-out directly. */
        bio = bio_list_get(&plug->pending);
-       raid1_prepare_flush_writes(mddev->bitmap);
+       raid1_prepare_flush_writes(mddev);
        wake_up_barrier(conf);
 
        while (bio) { /* submit pending writes */

diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 87b8d19ab6014c7420a27d50fcdba2a9375202eb..e98061c01b44a61bb439be9c7ce841fd3a98b04e 100644 (file)
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -6768,7 +6768,7 @@ static void raid5d(struct md_thread *thread)
                        /* Now is a good time to flush some bitmap updates */
                        conf->seq_flush++;
                        spin_unlock_irq(&conf->device_lock);
-                       md_bitmap_unplug(mddev->bitmap);
+                       md_bitmap_unplug(mddev, true);
                        spin_lock_irq(&conf->device_lock);
                        conf->seq_write = conf->seq_flush;
                        activate_bit_delay(conf, conf->temp_inactive_list);