md/md-bitmap: factor behind write counters out from bitmap_{start/end}write()

behind_write is only used in raid1, prepare to refactor
bitmap_{start/end}write(), there are no functional changes.

Signed-off-by: Yu Kuai <yukuai3@huawei.com>
Reviewed-by: Xiao Ni <xni@redhat.com>
Link: https://lore.kernel.org/r/20250109015145.158868-2-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 d16a89d673a179f0a71b586f8998adb88a46890f..e1d3970c300d0bb8cfe1022d2384b5b6371fbd76 100644 (file)
--- a/drivers/md/md-bitmap.c
+++ b/drivers/md/md-bitmap.c
@@ -1671,24 +1671,13 @@ __acquires(bitmap->lock)
 }
 
 static int bitmap_startwrite(struct mddev *mddev, sector_t offset,
-                            unsigned long sectors, bool behind)
+                            unsigned long sectors)
 {
        struct bitmap *bitmap = mddev->bitmap;
 
        if (!bitmap)
                return 0;
 
-       if (behind) {
-               int bw;
-               atomic_inc(&bitmap->behind_writes);
-               bw = atomic_read(&bitmap->behind_writes);
-               if (bw > bitmap->behind_writes_used)
-                       bitmap->behind_writes_used = bw;
-
-               pr_debug("inc write-behind count %d/%lu\n",
-                        bw, bitmap->mddev->bitmap_info.max_write_behind);
-       }
-
        while (sectors) {
                sector_t blocks;
                bitmap_counter_t *bmc;
@@ -1737,21 +1726,13 @@ static int bitmap_startwrite(struct mddev *mddev, sector_t offset,
 }
 
 static void bitmap_endwrite(struct mddev *mddev, sector_t offset,
-                           unsigned long sectors, bool success, bool behind)
+                           unsigned long sectors, bool success)
 {
        struct bitmap *bitmap = mddev->bitmap;
 
        if (!bitmap)
                return;
 
-       if (behind) {
-               if (atomic_dec_and_test(&bitmap->behind_writes))
-                       wake_up(&bitmap->behind_wait);
-               pr_debug("dec write-behind count %d/%lu\n",
-                        atomic_read(&bitmap->behind_writes),
-                        bitmap->mddev->bitmap_info.max_write_behind);
-       }
-
        while (sectors) {
                sector_t blocks;
                unsigned long flags;
@@ -2062,6 +2043,37 @@ static void md_bitmap_free(void *data)
        kfree(bitmap);
 }
 
+static void bitmap_start_behind_write(struct mddev *mddev)
+{
+       struct bitmap *bitmap = mddev->bitmap;
+       int bw;
+
+       if (!bitmap)
+               return;
+
+       atomic_inc(&bitmap->behind_writes);
+       bw = atomic_read(&bitmap->behind_writes);
+       if (bw > bitmap->behind_writes_used)
+               bitmap->behind_writes_used = bw;
+
+       pr_debug("inc write-behind count %d/%lu\n",
+                bw, bitmap->mddev->bitmap_info.max_write_behind);
+}
+
+static void bitmap_end_behind_write(struct mddev *mddev)
+{
+       struct bitmap *bitmap = mddev->bitmap;
+
+       if (!bitmap)
+               return;
+
+       if (atomic_dec_and_test(&bitmap->behind_writes))
+               wake_up(&bitmap->behind_wait);
+       pr_debug("dec write-behind count %d/%lu\n",
+                atomic_read(&bitmap->behind_writes),
+                bitmap->mddev->bitmap_info.max_write_behind);
+}
+
 static void bitmap_wait_behind_writes(struct mddev *mddev)
 {
        struct bitmap *bitmap = mddev->bitmap;
@@ -2981,6 +2993,9 @@ static struct bitmap_operations bitmap_ops = {
        .dirty_bits             = bitmap_dirty_bits,
        .unplug                 = bitmap_unplug,
        .daemon_work            = bitmap_daemon_work,
+
+       .start_behind_write     = bitmap_start_behind_write,
+       .end_behind_write       = bitmap_end_behind_write,
        .wait_behind_writes     = bitmap_wait_behind_writes,
 
        .startwrite             = bitmap_startwrite,

diff --git a/drivers/md/md-bitmap.h b/drivers/md/md-bitmap.h
index 662e6fc141a77554c8685c684bd66c02f14553cf..e87a1f493d3c1495318b0f9a5e866e8e2b71df8b 100644 (file)
--- a/drivers/md/md-bitmap.h
+++ b/drivers/md/md-bitmap.h
@@ -84,12 +84,15 @@ struct bitmap_operations {
                           unsigned long e);
        void (*unplug)(struct mddev *mddev, bool sync);
        void (*daemon_work)(struct mddev *mddev);
+
+       void (*start_behind_write)(struct mddev *mddev);
+       void (*end_behind_write)(struct mddev *mddev);
        void (*wait_behind_writes)(struct mddev *mddev);
 
        int (*startwrite)(struct mddev *mddev, sector_t offset,
-                         unsigned long sectors, bool behind);
+                         unsigned long sectors);
        void (*endwrite)(struct mddev *mddev, sector_t offset,
-                        unsigned long sectors, bool success, bool behind);
+                        unsigned long sectors, bool success);
        bool (*start_sync)(struct mddev *mddev, sector_t offset,
                           sector_t *blocks, bool degraded);
        void (*end_sync)(struct mddev *mddev, sector_t offset, sector_t *blocks);

diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 519c56f0ee3d40e97cfd4343e43e81610bfeeb3c..15ba7a001f30c73b606b12c9e5c50240e188f803 100644 (file)
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -420,10 +420,11 @@ static void close_write(struct r1bio *r1_bio)
                r1_bio->behind_master_bio = NULL;
        }
 
+       if (test_bit(R1BIO_BehindIO, &r1_bio->state))
+               mddev->bitmap_ops->end_behind_write(mddev);
        /* clear the bitmap if all writes complete successfully */
        mddev->bitmap_ops->endwrite(mddev, r1_bio->sector, r1_bio->sectors,
-                                   !test_bit(R1BIO_Degraded, &r1_bio->state),
-                                   test_bit(R1BIO_BehindIO, &r1_bio->state));
+                                   !test_bit(R1BIO_Degraded, &r1_bio->state));
        md_write_end(mddev);
 }
 
@@ -1645,9 +1646,10 @@ static void raid1_write_request(struct mddev *mddev, struct bio *bio,
                            stats.behind_writes < max_write_behind)
                                alloc_behind_master_bio(r1_bio, bio);
 
-                       mddev->bitmap_ops->startwrite(
-                               mddev, r1_bio->sector, r1_bio->sectors,
-                               test_bit(R1BIO_BehindIO, &r1_bio->state));
+                       if (test_bit(R1BIO_BehindIO, &r1_bio->state))
+                               mddev->bitmap_ops->start_behind_write(mddev);
+                       mddev->bitmap_ops->startwrite(mddev, r1_bio->sector,
+                                                     r1_bio->sectors);
                        first_clone = 0;
                }
 

diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 7d7a8a2524dcab91c7d84bb9af49d827fd370122..c3a93b2a26a6b6a0577f19dc20a6b822701f17cb 100644 (file)
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -430,8 +430,7 @@ static void close_write(struct r10bio *r10_bio)
 
        /* clear the bitmap if all writes complete successfully */
        mddev->bitmap_ops->endwrite(mddev, r10_bio->sector, r10_bio->sectors,
-                                   !test_bit(R10BIO_Degraded, &r10_bio->state),
-                                   false);
+                                   !test_bit(R10BIO_Degraded, &r10_bio->state));
        md_write_end(mddev);
 }
 
@@ -1519,8 +1518,7 @@ static void raid10_write_request(struct mddev *mddev, struct bio *bio,
        md_account_bio(mddev, &bio);
        r10_bio->master_bio = bio;
        atomic_set(&r10_bio->remaining, 1);
-       mddev->bitmap_ops->startwrite(mddev, r10_bio->sector, r10_bio->sectors,
-                                     false);
+       mddev->bitmap_ops->startwrite(mddev, r10_bio->sector, r10_bio->sectors);
 
        for (i = 0; i < conf->copies; i++) {
                if (r10_bio->devs[i].bio)

diff --git a/drivers/md/raid5-cache.c b/drivers/md/raid5-cache.c
index 7a22cb2e5ac3869e9dfb9572d318330ed5d9f8b9..1ac33d82bf8c9c53884ca40db1f8b5d6c4621b71 100644 (file)
--- a/drivers/md/raid5-cache.c
+++ b/drivers/md/raid5-cache.c
@@ -315,8 +315,7 @@ void r5c_handle_cached_data_endio(struct r5conf *conf,
                        r5c_return_dev_pending_writes(conf, &sh->dev[i]);
                        conf->mddev->bitmap_ops->endwrite(conf->mddev,
                                        sh->sector, RAID5_STRIPE_SECTORS(conf),
-                                       !test_bit(STRIPE_DEGRADED, &sh->state),
-                                       false);
+                                       !test_bit(STRIPE_DEGRADED, &sh->state));
                }
        }
 }

diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index f09e7677ee9f1b4b61b469fc448caf20918afdbc..93cc7e252dd47168fecd4d1164bdbc0d5179f356 100644 (file)
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -3564,7 +3564,7 @@ static void __add_stripe_bio(struct stripe_head *sh, struct bio *bi,
                set_bit(STRIPE_BITMAP_PENDING, &sh->state);
                spin_unlock_irq(&sh->stripe_lock);
                conf->mddev->bitmap_ops->startwrite(conf->mddev, sh->sector,
-                                       RAID5_STRIPE_SECTORS(conf), false);
+                                       RAID5_STRIPE_SECTORS(conf));
                spin_lock_irq(&sh->stripe_lock);
                clear_bit(STRIPE_BITMAP_PENDING, &sh->state);
                if (!sh->batch_head) {
@@ -3665,7 +3665,7 @@ handle_failed_stripe(struct r5conf *conf, struct stripe_head *sh,
                if (bitmap_end)
                        conf->mddev->bitmap_ops->endwrite(conf->mddev,
                                        sh->sector, RAID5_STRIPE_SECTORS(conf),
-                                       false, false);
+                                       false);
                bitmap_end = 0;
                /* and fail all 'written' */
                bi = sh->dev[i].written;
@@ -3712,7 +3712,7 @@ handle_failed_stripe(struct r5conf *conf, struct stripe_head *sh,
                if (bitmap_end)
                        conf->mddev->bitmap_ops->endwrite(conf->mddev,
                                        sh->sector, RAID5_STRIPE_SECTORS(conf),
-                                       false, false);
+                                       false);
                /* If we were in the middle of a write the parity block might
                 * still be locked - so just clear all R5_LOCKED flags
                 */
@@ -4063,8 +4063,7 @@ returnbi:
                                }
                                conf->mddev->bitmap_ops->endwrite(conf->mddev,
                                        sh->sector, RAID5_STRIPE_SECTORS(conf),
-                                       !test_bit(STRIPE_DEGRADED, &sh->state),
-                                       false);
+                                       !test_bit(STRIPE_DEGRADED, &sh->state));
                                if (head_sh->batch_head) {
                                        sh = list_first_entry(&sh->batch_list,
                                                              struct stripe_head,
@@ -5787,7 +5786,7 @@ static void make_discard_request(struct mddev *mddev, struct bio *bi)
                        for (d = 0; d < conf->raid_disks - conf->max_degraded;
                             d++)
                                mddev->bitmap_ops->startwrite(mddev, sh->sector,
-                                       RAID5_STRIPE_SECTORS(conf), false);
+                                       RAID5_STRIPE_SECTORS(conf));
                        sh->bm_seq = conf->seq_flush + 1;
                        set_bit(STRIPE_BIT_DELAY, &sh->state);
                }