md/md-bitmap: merge md_bitmap_start_sync() into bitmap_operations

So that the implementation won't be exposed, and it'll be possible
to invent a new bitmap by replacing bitmap_operations.

Also change the parameter from bitmap to mddev, to avoid access
bitmap outside md-bitmap.c as much as possible.

Also fix lots of code style.

Signed-off-by: Yu Kuai <yukuai3@huawei.com>
Link: https://lore.kernel.org/r/20240826074452.1490072-26-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 4d174ab2533982258fd2498d6b2a7a122bff15bc..57a4bae50e9cfb2cd91eb8d25c0d30374f69add3 100644 (file)
--- a/drivers/md/md-bitmap.c
+++ b/drivers/md/md-bitmap.c
@@ -1579,24 +1579,26 @@ static void bitmap_endwrite(struct mddev *mddev, sector_t offset,
        }
 }
 
-static int __bitmap_start_sync(struct bitmap *bitmap, sector_t offset, sector_t *blocks,
-                              int degraded)
+static bool __bitmap_start_sync(struct bitmap *bitmap, sector_t offset,
+                               sector_t *blocks, bool degraded)
 {
        bitmap_counter_t *bmc;
-       int rv;
+       bool rv;
+
        if (bitmap == NULL) {/* FIXME or bitmap set as 'failed' */
                *blocks = 1024;
-               return 1; /* always resync if no bitmap */
+               return true; /* always resync if no bitmap */
        }
        spin_lock_irq(&bitmap->counts.lock);
+
+       rv = false;
        bmc = md_bitmap_get_counter(&bitmap->counts, offset, blocks, 0);
-       rv = 0;
        if (bmc) {
                /* locked */
-               if (RESYNC(*bmc))
-                       rv = 1;
-               else if (NEEDED(*bmc)) {
-                       rv = 1;
+               if (RESYNC(*bmc)) {
+                       rv = true;
+               } else if (NEEDED(*bmc)) {
+                       rv = true;
                        if (!degraded) { /* don't set/clear bits if degraded */
                                *bmc |= RESYNC_MASK;
                                *bmc &= ~NEEDED_MASK;
@@ -1604,11 +1606,12 @@ static int __bitmap_start_sync(struct bitmap *bitmap, sector_t offset, sector_t
                }
        }
        spin_unlock_irq(&bitmap->counts.lock);
+
        return rv;
 }
 
-int md_bitmap_start_sync(struct bitmap *bitmap, sector_t offset, sector_t *blocks,
-                        int degraded)
+static bool bitmap_start_sync(struct mddev *mddev, sector_t offset,
+                             sector_t *blocks, bool degraded)
 {
        /* bitmap_start_sync must always report on multiples of whole
         * pages, otherwise resync (which is very PAGE_SIZE based) will
@@ -1617,19 +1620,19 @@ int md_bitmap_start_sync(struct bitmap *bitmap, sector_t offset, sector_t *block
         * At least PAGE_SIZE>>9 blocks are covered.
         * Return the 'or' of the result.
         */
-       int rv = 0;
+       bool rv = false;
        sector_t blocks1;
 
        *blocks = 0;
        while (*blocks < (PAGE_SIZE>>9)) {
-               rv |= __bitmap_start_sync(bitmap, offset,
+               rv |= __bitmap_start_sync(mddev->bitmap, offset,
                                          &blocks1, degraded);
                offset += blocks1;
                *blocks += blocks1;
        }
+
        return rv;
 }
-EXPORT_SYMBOL(md_bitmap_start_sync);
 
 void md_bitmap_end_sync(struct bitmap *bitmap, sector_t offset, sector_t *blocks, int aborted)
 {
@@ -1723,7 +1726,7 @@ void md_bitmap_sync_with_cluster(struct mddev *mddev,
        WARN((blocks > new_lo) && old_lo, "alignment is not correct for lo\n");
 
        for (sector = old_hi; sector < new_hi; ) {
-               md_bitmap_start_sync(bitmap, sector, &blocks, 0);
+               bitmap_start_sync(mddev, sector, &blocks, false);
                sector += blocks;
        }
        WARN((blocks > new_hi) && old_hi, "alignment is not correct for hi\n");
@@ -2005,7 +2008,7 @@ static int bitmap_load(struct mddev *mddev)
         */
        while (sector < mddev->resync_max_sectors) {
                sector_t blocks;
-               md_bitmap_start_sync(bitmap, sector, &blocks, 0);
+               bitmap_start_sync(mddev, sector, &blocks, false);
                sector += blocks;
        }
        md_bitmap_close_sync(bitmap);
@@ -2734,6 +2737,7 @@ static struct bitmap_operations bitmap_ops = {
 
        .startwrite             = bitmap_startwrite,
        .endwrite               = bitmap_endwrite,
+       .start_sync             = bitmap_start_sync,
 
        .update_sb              = bitmap_update_sb,
        .get_stats              = bitmap_get_stats,

diff --git a/drivers/md/md-bitmap.h b/drivers/md/md-bitmap.h
index 056a80ee500f578289fe6e6a68e83333b5727423..67c8f22e8726df98d740d570d7f14c77f76a4cf8 100644 (file)
--- a/drivers/md/md-bitmap.h
+++ b/drivers/md/md-bitmap.h
@@ -259,6 +259,8 @@ struct bitmap_operations {
                          unsigned long sectors, bool behind);
        void (*endwrite)(struct mddev *mddev, sector_t offset,
                         unsigned long sectors, bool success, bool behind);
+       bool (*start_sync)(struct mddev *mddev, sector_t offset,
+                          sector_t *blocks, bool degraded);
 
        void (*update_sb)(struct bitmap *bitmap);
        int (*get_stats)(struct bitmap *bitmap, struct md_bitmap_stats *stats);
@@ -268,7 +270,6 @@ struct bitmap_operations {
 void mddev_set_bitmap_ops(struct mddev *mddev);
 
 /* these are exported */
-int md_bitmap_start_sync(struct bitmap *bitmap, sector_t offset, sector_t *blocks, int degraded);
 void md_bitmap_end_sync(struct bitmap *bitmap, sector_t offset, sector_t *blocks, int aborted);
 void md_bitmap_close_sync(struct bitmap *bitmap);
 void md_bitmap_cond_end_sync(struct bitmap *bitmap, sector_t sector, bool force);

diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index b335293ec472883a326c03a8ed2bf661f0579153..8b83dd83e15f99f1ed7367228ad3a26521f3fbdd 100644 (file)
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -2755,7 +2755,7 @@ static sector_t raid1_sync_request(struct mddev *mddev, sector_t sector_nr,
        int wonly = -1;
        int write_targets = 0, read_targets = 0;
        sector_t sync_blocks;
-       int still_degraded = 0;
+       bool still_degraded = false;
        int good_sectors = RESYNC_SECTORS;
        int min_bad = 0; /* number of sectors that are bad in all devices */
        int idx = sector_to_idx(sector_nr);
@@ -2797,7 +2797,7 @@ static sector_t raid1_sync_request(struct mddev *mddev, sector_t sector_nr,
        /* before building a request, check if we can skip these blocks..
         * This call the bitmap_start_sync doesn't actually record anything
         */
-       if (!md_bitmap_start_sync(mddev->bitmap, sector_nr, &sync_blocks, 1) &&
+       if (!mddev->bitmap_ops->start_sync(mddev, sector_nr, &sync_blocks, true) &&
            !conf->fullsync && !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
                /* We can skip this block, and probably several more */
                *skipped = 1;
@@ -2848,7 +2848,7 @@ static sector_t raid1_sync_request(struct mddev *mddev, sector_t sector_nr,
                if (rdev == NULL ||
                    test_bit(Faulty, &rdev->flags)) {
                        if (i < conf->raid_disks)
-                               still_degraded = 1;
+                               still_degraded = true;
                } else if (!test_bit(In_sync, &rdev->flags)) {
                        bio->bi_opf = REQ_OP_WRITE;
                        bio->bi_end_io = end_sync_write;
@@ -2972,8 +2972,8 @@ static sector_t raid1_sync_request(struct mddev *mddev, sector_t sector_nr,
                if (len == 0)
                        break;
                if (sync_blocks == 0) {
-                       if (!md_bitmap_start_sync(mddev->bitmap, sector_nr,
-                                                 &sync_blocks, still_degraded) &&
+                       if (!mddev->bitmap_ops->start_sync(mddev, sector_nr,
+                                               &sync_blocks, still_degraded) &&
                            !conf->fullsync &&
                            !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
                                break;

diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index ce28150e0464a856de52eee6b11c7bdac633ea63..d88878741ed470589b57ef931b62f0b5952af01b 100644 (file)
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -3289,10 +3289,10 @@ static sector_t raid10_sync_request(struct mddev *mddev, sector_t sector_nr,
                r10_bio = NULL;
 
                for (i = 0 ; i < conf->geo.raid_disks; i++) {
-                       int still_degraded;
+                       bool still_degraded;
                        struct r10bio *rb2;
                        sector_t sect;
-                       int must_sync;
+                       bool must_sync;
                        int any_working;
                        struct raid10_info *mirror = &conf->mirrors[i];
                        struct md_rdev *mrdev, *mreplace;
@@ -3309,7 +3309,7 @@ static sector_t raid10_sync_request(struct mddev *mddev, sector_t sector_nr,
                        if (!mrdev && !mreplace)
                                continue;
 
-                       still_degraded = 0;
+                       still_degraded = false;
                        /* want to reconstruct this device */
                        rb2 = r10_bio;
                        sect = raid10_find_virt(conf, sector_nr, i);
@@ -3322,8 +3322,9 @@ static sector_t raid10_sync_request(struct mddev *mddev, sector_t sector_nr,
                         * we only need to recover the block if it is set in
                         * the bitmap
                         */
-                       must_sync = md_bitmap_start_sync(mddev->bitmap, sect,
-                                                        &sync_blocks, 1);
+                       must_sync = mddev->bitmap_ops->start_sync(mddev, sect,
+                                                                 &sync_blocks,
+                                                                 true);
                        if (sync_blocks < max_sync)
                                max_sync = sync_blocks;
                        if (!must_sync &&
@@ -3361,13 +3362,13 @@ static sector_t raid10_sync_request(struct mddev *mddev, sector_t sector_nr,
                                struct md_rdev *rdev = conf->mirrors[j].rdev;
 
                                if (rdev == NULL || test_bit(Faulty, &rdev->flags)) {
-                                       still_degraded = 1;
+                                       still_degraded = false;
                                        break;
                                }
                        }
 
-                       must_sync = md_bitmap_start_sync(mddev->bitmap, sect,
-                                                        &sync_blocks, still_degraded);
+                       must_sync = mddev->bitmap_ops->start_sync(mddev, sect,
+                                               &sync_blocks, still_degraded);
 
                        any_working = 0;
                        for (j=0; j<conf->copies;j++) {
@@ -3544,8 +3545,9 @@ static sector_t raid10_sync_request(struct mddev *mddev, sector_t sector_nr,
                                        mddev_is_clustered(mddev) &&
                                        (sector_nr + 2 * RESYNC_SECTORS > conf->cluster_sync_high));
 
-               if (!md_bitmap_start_sync(mddev->bitmap, sector_nr,
-                                         &sync_blocks, mddev->degraded) &&
+               if (!mddev->bitmap_ops->start_sync(mddev, sector_nr,
+                                                  &sync_blocks,
+                                                  mddev->degraded) &&
                    !conf->fullsync && !test_bit(MD_RECOVERY_REQUESTED,
                                                 &mddev->recovery)) {
                        /* We can skip this block */

diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 93d582b9f922e34fa3e4f97a1c28bcdad873e53e..313904dd6555b1bda95a4258f6878c8f13454fe4 100644 (file)
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -6485,7 +6485,7 @@ static inline sector_t raid5_sync_request(struct mddev *mddev, sector_t sector_n
        struct r5conf *conf = mddev->private;
        struct stripe_head *sh;
        sector_t sync_blocks;
-       int still_degraded = 0;
+       bool still_degraded = false;
        int i;
 
        if (sector_nr >= max_sector) {
@@ -6530,7 +6530,8 @@ static inline sector_t raid5_sync_request(struct mddev *mddev, sector_t sector_n
        }
        if (!test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery) &&
            !conf->fullsync &&
-           !md_bitmap_start_sync(mddev->bitmap, sector_nr, &sync_blocks, 1) &&
+           !mddev->bitmap_ops->start_sync(mddev, sector_nr, &sync_blocks,
+                                          true) &&
            sync_blocks >= RAID5_STRIPE_SECTORS(conf)) {
                /* we can skip this block, and probably more */
                do_div(sync_blocks, RAID5_STRIPE_SECTORS(conf));
@@ -6558,10 +6559,11 @@ static inline sector_t raid5_sync_request(struct mddev *mddev, sector_t sector_n
                struct md_rdev *rdev = conf->disks[i].rdev;
 
                if (rdev == NULL || test_bit(Faulty, &rdev->flags))
-                       still_degraded = 1;
+                       still_degraded = true;
        }
 
-       md_bitmap_start_sync(mddev->bitmap, sector_nr, &sync_blocks, still_degraded);
+       mddev->bitmap_ops->start_sync(mddev, sector_nr, &sync_blocks,
+                                     still_degraded);
 
        set_bit(STRIPE_SYNC_REQUESTED, &sh->state);
        set_bit(STRIPE_HANDLE, &sh->state);