Commit 178d1391 authored by Wang Jinchao's avatar Wang Jinchao Committed by Yu Kuai
Browse files

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: default avatarWang Jinchao <wangjinchao600@gmail.com>
Link: https://lore.kernel.org/linux-raid/20250707012711.376844-3-yukuai1@huaweicloud.com


Signed-off-by: default avatarYu Kuai <yukuai3@huawei.com>
parent 987ca606

drivers/md/raid1.c

+14 −35
Original line number Diff line number Diff line
@@ -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 @@ static void * r1buf_pool_alloc(gfp_t gfp_flags, void *data) 
		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 @@ static void * r1buf_pool_alloc(gfp_t gfp_flags, void *data) 


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);

drivers/md/raid1.h

+0 −20
Original line number Diff line number Diff line
@@ -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;