md/raid1: remove struct pool_info and related code

The struct pool_info was originally introduced mainly to support reshape
operations, serving as a parameter for mempool_init() when raid_disks
changes. Now that mempool_create_kmalloc_pool() is sufficient for this
purpose, struct pool_info and its related code are no longer needed.

Remove struct pool_info and all associated code.

Signed-off-by: Wang Jinchao <wangjinchao600@gmail.com>
Link: https://lore.kernel.org/linux-raid/20250707012711.376844-3-yukuai1@huaweicloud.com
Signed-off-by: Yu Kuai <yukuai3@huawei.com>

diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 589223fef20a9f7b3b819734af9c180f29b6d69e..408c263983215e0ae1ba9e96095e07d23988e3ec 100644 (file)
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -127,10 +127,9 @@ static inline struct r1bio *get_resync_r1bio(struct bio *bio)
        return get_resync_pages(bio)->raid_bio;
 }
 
-static void * r1bio_pool_alloc(gfp_t gfp_flags, void *data)
+static void *r1bio_pool_alloc(gfp_t gfp_flags, struct r1conf *conf)
 {
-       struct pool_info *pi = data;
-       int size = offsetof(struct r1bio, bios[pi->raid_disks]);
+       int size = offsetof(struct r1bio, bios[conf->raid_disks * 2]);
 
        /* allocate a r1bio with room for raid_disks entries in the bios array */
        return kzalloc(size, gfp_flags);
@@ -145,18 +144,18 @@ static void * r1bio_pool_alloc(gfp_t gfp_flags, void *data)
 
 static void * r1buf_pool_alloc(gfp_t gfp_flags, void *data)
 {
-       struct pool_info *pi = data;
+       struct r1conf *conf = data;
        struct r1bio *r1_bio;
        struct bio *bio;
        int need_pages;
        int j;
        struct resync_pages *rps;
 
-       r1_bio = r1bio_pool_alloc(gfp_flags, pi);
+       r1_bio = r1bio_pool_alloc(gfp_flags, conf);
        if (!r1_bio)
                return NULL;
 
-       rps = kmalloc_array(pi->raid_disks, sizeof(struct resync_pages),
+       rps = kmalloc_array(conf->raid_disks * 2, sizeof(struct resync_pages),
                            gfp_flags);
        if (!rps)
                goto out_free_r1bio;
@@ -164,7 +163,7 @@ static void * r1buf_pool_alloc(gfp_t gfp_flags, void *data)
        /*
         * Allocate bios : 1 for reading, n-1 for writing
         */
-       for (j = pi->raid_disks ; j-- ; ) {
+       for (j = conf->raid_disks * 2; j-- ; ) {
                bio = bio_kmalloc(RESYNC_PAGES, gfp_flags);
                if (!bio)
                        goto out_free_bio;
@@ -177,11 +176,11 @@ static void * r1buf_pool_alloc(gfp_t gfp_flags, void *data)
         * If this is a user-requested check/repair, allocate
         * RESYNC_PAGES for each bio.
         */
-       if (test_bit(MD_RECOVERY_REQUESTED, &pi->mddev->recovery))
-               need_pages = pi->raid_disks;
+       if (test_bit(MD_RECOVERY_REQUESTED, &conf->mddev->recovery))
+               need_pages = conf->raid_disks * 2;
        else
                need_pages = 1;
-       for (j = 0; j < pi->raid_disks; j++) {
+       for (j = 0; j < conf->raid_disks * 2; j++) {
                struct resync_pages *rp = &rps[j];
 
                bio = r1_bio->bios[j];
@@ -207,7 +206,7 @@ out_free_pages:
                resync_free_pages(&rps[j]);
 
 out_free_bio:
-       while (++j < pi->raid_disks) {
+       while (++j < conf->raid_disks * 2) {
                bio_uninit(r1_bio->bios[j]);
                kfree(r1_bio->bios[j]);
        }
@@ -220,12 +219,12 @@ out_free_r1bio:
 
 static void r1buf_pool_free(void *__r1_bio, void *data)
 {
-       struct pool_info *pi = data;
+       struct r1conf *conf = data;
        int i;
        struct r1bio *r1bio = __r1_bio;
        struct resync_pages *rp = NULL;
 
-       for (i = pi->raid_disks; i--; ) {
+       for (i = conf->raid_disks * 2; i--; ) {
                rp = get_resync_pages(r1bio->bios[i]);
                resync_free_pages(rp);
                bio_uninit(r1bio->bios[i]);
@@ -2746,7 +2745,7 @@ static int init_resync(struct r1conf *conf)
        BUG_ON(mempool_initialized(&conf->r1buf_pool));
 
        return mempool_init(&conf->r1buf_pool, buffs, r1buf_pool_alloc,
-                           r1buf_pool_free, conf->poolinfo);
+                           r1buf_pool_free, conf);
 }
 
 static struct r1bio *raid1_alloc_init_r1buf(struct r1conf *conf)
@@ -2756,7 +2755,7 @@ static struct r1bio *raid1_alloc_init_r1buf(struct r1conf *conf)
        struct bio *bio;
        int i;
 
-       for (i = conf->poolinfo->raid_disks; i--; ) {
+       for (i = conf->raid_disks * 2; i--; ) {
                bio = r1bio->bios[i];
                rps = bio->bi_private;
                bio_reset(bio, NULL, 0);
@@ -3121,11 +3120,6 @@ static struct r1conf *setup_conf(struct mddev *mddev)
        if (!conf->tmppage)
                goto abort;
 
-       conf->poolinfo = kzalloc(sizeof(*conf->poolinfo), GFP_KERNEL);
-       if (!conf->poolinfo)
-               goto abort;
-       conf->poolinfo->raid_disks = mddev->raid_disks * 2;
-
        r1bio_size = offsetof(struct r1bio, bios[mddev->raid_disks * 2]);
        conf->r1bio_pool = mempool_create_kmalloc_pool(NR_RAID_BIOS, r1bio_size);
        if (!conf->r1bio_pool)
@@ -3135,8 +3129,6 @@ static struct r1conf *setup_conf(struct mddev *mddev)
        if (err)
                goto abort;
 
-       conf->poolinfo->mddev = mddev;
-
        err = -EINVAL;
        spin_lock_init(&conf->device_lock);
        conf->raid_disks = mddev->raid_disks;
@@ -3202,7 +3194,6 @@ static struct r1conf *setup_conf(struct mddev *mddev)
                mempool_destroy(conf->r1bio_pool);
                kfree(conf->mirrors);
                safe_put_page(conf->tmppage);
-               kfree(conf->poolinfo);
                kfree(conf->nr_pending);
                kfree(conf->nr_waiting);
                kfree(conf->nr_queued);
@@ -3315,7 +3306,6 @@ static void raid1_free(struct mddev *mddev, void *priv)
        mempool_destroy(conf->r1bio_pool);
        kfree(conf->mirrors);
        safe_put_page(conf->tmppage);
-       kfree(conf->poolinfo);
        kfree(conf->nr_pending);
        kfree(conf->nr_waiting);
        kfree(conf->nr_queued);
@@ -3369,7 +3359,6 @@ static int raid1_reshape(struct mddev *mddev)
         * devices have the higher raid_disk numbers.
         */
        mempool_t *newpool, *oldpool;
-       struct pool_info *newpoolinfo;
        size_t new_r1bio_size;
        struct raid1_info *newmirrors;
        struct r1conf *conf = mddev->private;
@@ -3401,23 +3390,15 @@ static int raid1_reshape(struct mddev *mddev)
                        return -EBUSY;
        }
 
-       newpoolinfo = kmalloc(sizeof(*newpoolinfo), GFP_KERNEL);
-       if (!newpoolinfo)
-               return -ENOMEM;
-       newpoolinfo->mddev = mddev;
-       newpoolinfo->raid_disks = raid_disks * 2;
-
        new_r1bio_size = offsetof(struct r1bio, bios[raid_disks * 2]);
        newpool = mempool_create_kmalloc_pool(NR_RAID_BIOS, new_r1bio_size);
        if (!newpool) {
-               kfree(newpoolinfo);
                return -ENOMEM;
        }
        newmirrors = kzalloc(array3_size(sizeof(struct raid1_info),
                                         raid_disks, 2),
                             GFP_KERNEL);
        if (!newmirrors) {
-               kfree(newpoolinfo);
                mempool_destroy(newpool);
                return -ENOMEM;
        }
@@ -3443,8 +3424,6 @@ static int raid1_reshape(struct mddev *mddev)
        }
        kfree(conf->mirrors);
        conf->mirrors = newmirrors;
-       kfree(conf->poolinfo);
-       conf->poolinfo = newpoolinfo;
 
        spin_lock_irqsave(&conf->device_lock, flags);
        mddev->degraded += (raid_disks - conf->raid_disks);

diff --git a/drivers/md/raid1.h b/drivers/md/raid1.h
index 652c347b1a70137e6b6cd66dc68d32f4b2a83ec8..d236ef179cfba0a301594a0ab52c7f7ff54937c2 100644 (file)
--- a/drivers/md/raid1.h
+++ b/drivers/md/raid1.h
@@ -49,22 +49,6 @@ struct raid1_info {
        sector_t        seq_start;
 };
 
-/*
- * memory pools need a pointer to the mddev, so they can force an unplug
- * when memory is tight, and a count of the number of drives that the
- * pool was allocated for, so they know how much to allocate and free.
- * mddev->raid_disks cannot be used, as it can change while a pool is active
- * These two datums are stored in a kmalloced struct.
- * The 'raid_disks' here is twice the raid_disks in r1conf.
- * This allows space for each 'real' device can have a replacement in the
- * second half of the array.
- */
-
-struct pool_info {
-       struct mddev *mddev;
-       int     raid_disks;
-};
-
 struct r1conf {
        struct mddev            *mddev;
        struct raid1_info       *mirrors;       /* twice 'raid_disks' to
@@ -114,10 +98,6 @@ struct r1conf {
         */
        int                     recovery_disabled;
 
-       /* poolinfo contains information about the content of the
-        * mempools - it changes when the array grows or shrinks
-        */
-       struct pool_info        *poolinfo;
        mempool_t               *r1bio_pool;
        mempool_t               r1buf_pool;