* [PATCH v5 10/12] md/raid10: align bio to io_opt
From: Yu Kuai @ 2026-01-14 17:12 UTC (permalink / raw)
To: linux-raid; +Cc: yukuai, linan122, xni, dan.carpenter
In-Reply-To: <20260114171241.3043364-1-yukuai@fnnas.com>
The impact is not so significant for raid10 compared to raid5, however
it's still more appropriate to issue IOs evenly to underlying disks.
Signed-off-by: Yu Kuai <yukuai@fnnas.com>
Reviewed-by: Li Nan <linan122@huawei.com>
---
drivers/md/raid10.c | 2 ++
1 file changed, 2 insertions(+)
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 09328e032f14..2c6b65b83724 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -4008,6 +4008,8 @@ static int raid10_set_queue_limits(struct mddev *mddev)
err = mddev_stack_rdev_limits(mddev, &lim, MDDEV_STACK_INTEGRITY);
if (err)
return err;
+
+ md_config_align_limits(mddev, &lim);
return queue_limits_set(mddev->gendisk->queue, &lim);
}
--
2.51.0
^ permalink raw reply related
* [PATCH v5 09/12] md/raid5: align bio to io_opt
From: Yu Kuai @ 2026-01-14 17:12 UTC (permalink / raw)
To: linux-raid; +Cc: yukuai, linan122, xni, dan.carpenter
In-Reply-To: <20260114171241.3043364-1-yukuai@fnnas.com>
raid5 internal implementaion indicates that if write bio is aligned to
io_opt, then full stripe write will be used, which will be best for
bandwidth because there is no need to read extra data to build new
xor data.
Simple test in my VM, 32 disks raid5 with 64kb chunksize:
dd if=/dev/zero of=/dev/md0 bs=100M oflag=direct
Before this patch: 782 MB/s
With this patch: 1.1 GB/s
BTW, there are still other bottleneck related to stripe handler, and
require further optimization.
Signed-off-by: Yu Kuai <yukuai@fnnas.com>
Reviewed-by: Li Nan <linan122@huawei.com>
---
drivers/md/raid5.c | 6 ++----
1 file changed, 2 insertions(+), 4 deletions(-)
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index d4a44fe0b5a5..bbcf4b1127e7 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -59,8 +59,7 @@
#define UNSUPPORTED_MDDEV_FLAGS \
((1L << MD_FAILFAST_SUPPORTED) | \
(1L << MD_FAILLAST_DEV) | \
- (1L << MD_SERIALIZE_POLICY) | \
- (1L << MD_BIO_ALIGN))
+ (1L << MD_SERIALIZE_POLICY))
#define cpu_to_group(cpu) cpu_to_node(cpu)
@@ -7817,8 +7816,7 @@ static int raid5_set_limits(struct mddev *mddev)
* Limit the max sectors based on this.
*/
lim.max_hw_sectors = RAID5_MAX_REQ_STRIPES << RAID5_STRIPE_SHIFT(conf);
- if ((lim.max_hw_sectors << 9) < lim.io_opt)
- lim.max_hw_sectors = lim.io_opt >> 9;
+ md_config_align_limits(mddev, &lim);
/* No restrictions on the number of segments in the request */
lim.max_segments = USHRT_MAX;
--
2.51.0
^ permalink raw reply related
* [PATCH v5 08/12] md: add a helper md_config_align_limits()
From: Yu Kuai @ 2026-01-14 17:12 UTC (permalink / raw)
To: linux-raid; +Cc: yukuai, linan122, xni, dan.carpenter
In-Reply-To: <20260114171241.3043364-1-yukuai@fnnas.com>
This helper will be used by personalities that want to align bio to
io_opt to get best IO bandwidth.
Also add the new flag to UNSUPPORTED_MDDEV_FLAGS for now, following
patches will enable this for personalities.
Signed-off-by: Yu Kuai <yukuai@fnnas.com>
Reviewed-by: Li Nan <linan122@huawei.com>
---
drivers/md/md.h | 11 +++++++++++
drivers/md/raid0.c | 3 ++-
drivers/md/raid1.c | 3 ++-
drivers/md/raid5.c | 3 ++-
4 files changed, 17 insertions(+), 3 deletions(-)
diff --git a/drivers/md/md.h b/drivers/md/md.h
index e7aba83b708b..ddf989f2a139 100644
--- a/drivers/md/md.h
+++ b/drivers/md/md.h
@@ -1091,6 +1091,17 @@ static inline bool rdev_blocked(struct md_rdev *rdev)
return false;
}
+static inline void md_config_align_limits(struct mddev *mddev,
+ struct queue_limits *lim)
+{
+ if ((lim->max_hw_sectors << 9) < lim->io_opt)
+ lim->max_hw_sectors = lim->io_opt >> 9;
+ else
+ lim->max_hw_sectors = rounddown(lim->max_hw_sectors,
+ lim->io_opt >> 9);
+ set_bit(MD_BIO_ALIGN, &mddev->flags);
+}
+
#define mddev_add_trace_msg(mddev, fmt, args...) \
do { \
if (!mddev_is_dm(mddev)) \
diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index d83b2b1c0049..f3814a69cd13 100644
--- a/drivers/md/raid0.c
+++ b/drivers/md/raid0.c
@@ -29,7 +29,8 @@ module_param(default_layout, int, 0644);
(1L << MD_HAS_PPL) | \
(1L << MD_HAS_MULTIPLE_PPLS) | \
(1L << MD_FAILLAST_DEV) | \
- (1L << MD_SERIALIZE_POLICY))
+ (1L << MD_SERIALIZE_POLICY) | \
+ (1L << MD_BIO_ALIGN))
/*
* inform the user of the raid configuration
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index f4c7004888af..1a957dba2640 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -42,7 +42,8 @@
((1L << MD_HAS_JOURNAL) | \
(1L << MD_JOURNAL_CLEAN) | \
(1L << MD_HAS_PPL) | \
- (1L << MD_HAS_MULTIPLE_PPLS))
+ (1L << MD_HAS_MULTIPLE_PPLS) | \
+ (1L << MD_BIO_ALIGN))
static void allow_barrier(struct r1conf *conf, sector_t sector_nr);
static void lower_barrier(struct r1conf *conf, sector_t sector_nr);
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 8a7fed91d46b..d4a44fe0b5a5 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -59,7 +59,8 @@
#define UNSUPPORTED_MDDEV_FLAGS \
((1L << MD_FAILFAST_SUPPORTED) | \
(1L << MD_FAILLAST_DEV) | \
- (1L << MD_SERIALIZE_POLICY))
+ (1L << MD_SERIALIZE_POLICY) | \
+ (1L << MD_BIO_ALIGN))
#define cpu_to_group(cpu) cpu_to_node(cpu)
--
2.51.0
^ permalink raw reply related
* [PATCH v5 07/12] md: support to align bio to limits
From: Yu Kuai @ 2026-01-14 17:12 UTC (permalink / raw)
To: linux-raid; +Cc: yukuai, linan122, xni, dan.carpenter
In-Reply-To: <20260114171241.3043364-1-yukuai@fnnas.com>
For personalities that report optimal IO size, it indicates that users
can get the best IO bandwidth if they issue IO with this size. However
there is also an implicit condition that IO should also be aligned to the
optimal IO size.
Currently, bio will only be split by limits, if bio offset is not aligned
to limits, then all split bio will not be aligned. This patch add a new
feature to align bio to limits first, and following patches will support
this for each personality if necessary.
Signed-off-by: Yu Kuai <yukuai@fnnas.com>
Reviewed-by: Li Nan <linan122@huawei.com>
---
drivers/md/md.c | 54 +++++++++++++++++++++++++++++++++++++++++++++++++
drivers/md/md.h | 2 ++
2 files changed, 56 insertions(+)
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 21b0bc3088d2..731ec800f5cb 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -428,6 +428,56 @@ bool md_handle_request(struct mddev *mddev, struct bio *bio)
}
EXPORT_SYMBOL(md_handle_request);
+static struct bio *__md_bio_align_to_limits(struct mddev *mddev,
+ struct bio *bio)
+{
+ unsigned int max_sectors = mddev->gendisk->queue->limits.max_sectors;
+ sector_t start = bio->bi_iter.bi_sector;
+ sector_t end = start + bio_sectors(bio);
+ sector_t align_start;
+ sector_t align_end;
+ u32 rem;
+
+ /* calculate align_start = roundup(start, max_sectors) */
+ align_start = start;
+ rem = sector_div(align_start, max_sectors);
+ /* already aligned */
+ if (!rem)
+ return bio;
+
+ align_start = start + max_sectors - rem;
+
+ /* calculate align_end = rounddown(end, max_sectors) */
+ align_end = end;
+ rem = sector_div(align_end, max_sectors);
+ align_end = end - rem;
+
+ /* bio is too small to split */
+ if (align_end <= align_start)
+ return bio;
+
+ return bio_submit_split_bioset(bio, align_start - start,
+ &mddev->gendisk->bio_split);
+}
+
+static struct bio *md_bio_align_to_limits(struct mddev *mddev, struct bio *bio)
+{
+ if (!test_bit(MD_BIO_ALIGN, &mddev->flags))
+ return bio;
+
+ /* atomic write can't split */
+ if (bio->bi_opf & REQ_ATOMIC)
+ return bio;
+
+ switch (bio_op(bio)) {
+ case REQ_OP_READ:
+ case REQ_OP_WRITE:
+ return __md_bio_align_to_limits(mddev, bio);
+ default:
+ return bio;
+ }
+}
+
static void md_submit_bio(struct bio *bio)
{
const int rw = bio_data_dir(bio);
@@ -443,6 +493,10 @@ static void md_submit_bio(struct bio *bio)
return;
}
+ bio = md_bio_align_to_limits(mddev, bio);
+ if (!bio)
+ return;
+
bio = bio_split_to_limits(bio);
if (!bio)
return;
diff --git a/drivers/md/md.h b/drivers/md/md.h
index b8c5dec12b62..e7aba83b708b 100644
--- a/drivers/md/md.h
+++ b/drivers/md/md.h
@@ -347,6 +347,7 @@ struct md_cluster_operations;
* @MD_HAS_SUPERBLOCK: There is persistence sb in member disks.
* @MD_FAILLAST_DEV: Allow last rdev to be removed.
* @MD_SERIALIZE_POLICY: Enforce write IO is not reordered, just used by raid1.
+ * @MD_BIO_ALIGN: Bio issued to the array will align to io_opt before split.
*
* change UNSUPPORTED_MDDEV_FLAGS for each array type if new flag is added
*/
@@ -366,6 +367,7 @@ enum mddev_flags {
MD_HAS_SUPERBLOCK,
MD_FAILLAST_DEV,
MD_SERIALIZE_POLICY,
+ MD_BIO_ALIGN,
};
enum mddev_sb_flags {
--
2.51.0
^ permalink raw reply related
* [PATCH v5 06/12] md/raid5: make sure max_sectors is not less than io_opt
From: Yu Kuai @ 2026-01-14 17:12 UTC (permalink / raw)
To: linux-raid; +Cc: yukuai, linan122, xni, dan.carpenter
In-Reply-To: <20260114171241.3043364-1-yukuai@fnnas.com>
Otherwise, even if user issue IO by io_opt, such IO will be split
by max_sectors before they are submitted to raid5. For consequence,
full stripe IO is impossible.
BTW, dm-raid5 is not affected and still have such problem.
Signed-off-by: Yu Kuai <yukuai@fnnas.com>
---
drivers/md/raid5.c | 38 ++++++++++++++++++++++++++++----------
drivers/md/raid5.h | 1 +
2 files changed, 29 insertions(+), 10 deletions(-)
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index b250c6c9e72b..8a7fed91d46b 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -777,14 +777,14 @@ struct stripe_request_ctx {
/* last sector in the request */
sector_t last_sector;
+ /* the request had REQ_PREFLUSH, cleared after the first stripe_head */
+ bool do_flush;
+
/*
* bitmap to track stripe sectors that have been added to stripes
* add one to account for unaligned requests
*/
- DECLARE_BITMAP(sectors_to_do, RAID5_MAX_REQ_STRIPES + 1);
-
- /* the request had REQ_PREFLUSH, cleared after the first stripe_head */
- bool do_flush;
+ unsigned long sectors_to_do[];
};
/*
@@ -6127,7 +6127,7 @@ static bool raid5_make_request(struct mddev *mddev, struct bio * bi)
bi->bi_next = NULL;
ctx = mempool_alloc(conf->ctx_pool, GFP_NOIO);
- memset(ctx, 0, sizeof(*ctx));
+ memset(ctx, 0, conf->ctx_size);
ctx->first_sector = logical_sector;
ctx->last_sector = bio_end_sector(bi);
/*
@@ -7741,6 +7741,25 @@ static int only_parity(int raid_disk, int algo, int raid_disks, int max_degraded
return 0;
}
+static int raid5_create_ctx_pool(struct r5conf *conf)
+{
+ struct stripe_request_ctx *ctx;
+ int size;
+
+ if (mddev_is_dm(conf->mddev))
+ size = BITS_TO_LONGS(RAID5_MAX_REQ_STRIPES);
+ else
+ size = BITS_TO_LONGS(
+ queue_max_hw_sectors(conf->mddev->gendisk->queue) >>
+ RAID5_STRIPE_SHIFT(conf));
+
+ conf->ctx_size = struct_size(ctx, sectors_to_do, size);
+ conf->ctx_pool = mempool_create_kmalloc_pool(NR_RAID_BIOS,
+ conf->ctx_size);
+
+ return conf->ctx_pool ? 0 : -ENOMEM;
+}
+
static int raid5_set_limits(struct mddev *mddev)
{
struct r5conf *conf = mddev->private;
@@ -7797,6 +7816,8 @@ static int raid5_set_limits(struct mddev *mddev)
* Limit the max sectors based on this.
*/
lim.max_hw_sectors = RAID5_MAX_REQ_STRIPES << RAID5_STRIPE_SHIFT(conf);
+ if ((lim.max_hw_sectors << 9) < lim.io_opt)
+ lim.max_hw_sectors = lim.io_opt >> 9;
/* No restrictions on the number of segments in the request */
lim.max_segments = USHRT_MAX;
@@ -8069,12 +8090,9 @@ static int raid5_run(struct mddev *mddev)
goto abort;
}
- conf->ctx_pool = mempool_create_kmalloc_pool(NR_RAID_BIOS,
- sizeof(struct stripe_request_ctx));
- if (!conf->ctx_pool) {
- ret = -ENOMEM;
+ ret = raid5_create_ctx_pool(conf);
+ if (ret)
goto abort;
- }
ret = log_init(conf, journal_dev, raid5_has_ppl(conf));
if (ret)
diff --git a/drivers/md/raid5.h b/drivers/md/raid5.h
index 6e3f07119fa4..ddfe65237888 100644
--- a/drivers/md/raid5.h
+++ b/drivers/md/raid5.h
@@ -692,6 +692,7 @@ struct r5conf {
struct r5pending_data *next_pending_data;
mempool_t *ctx_pool;
+ int ctx_size;
};
#if PAGE_SIZE == DEFAULT_STRIPE_SIZE
--
2.51.0
^ permalink raw reply related
* [PATCH v5 05/12] md/raid5: use mempool to allocate stripe_request_ctx
From: Yu Kuai @ 2026-01-14 17:12 UTC (permalink / raw)
To: linux-raid; +Cc: yukuai, linan122, xni, dan.carpenter
In-Reply-To: <20260114171241.3043364-1-yukuai@fnnas.com>
On the one hand, stripe_request_ctx is 72 bytes, and it's a bit huge for
a stack variable.
On the other hand, the bitmap sectors_to_do is a fixed size, result in
max_hw_sector_kb of raid5 array is at most 256 * 4k = 1Mb, and this will
make full stripe IO impossible for the array that chunk_size * data_disks
is bigger. Allocate ctx during runtime will make it possible to get rid
of this limit.
Signed-off-by: Yu Kuai <yukuai@fnnas.com>
Reviewed-by: Li Nan <linan122@huawei.com>
---
drivers/md/md.h | 4 +++
drivers/md/raid1-10.c | 5 ----
drivers/md/raid5.c | 61 +++++++++++++++++++++++++++----------------
drivers/md/raid5.h | 2 ++
4 files changed, 45 insertions(+), 27 deletions(-)
diff --git a/drivers/md/md.h b/drivers/md/md.h
index 6ee18045f41c..b8c5dec12b62 100644
--- a/drivers/md/md.h
+++ b/drivers/md/md.h
@@ -22,6 +22,10 @@
#include <trace/events/block.h>
#define MaxSector (~(sector_t)0)
+/*
+ * Number of guaranteed raid bios in case of extreme VM load:
+ */
+#define NR_RAID_BIOS 256
enum md_submodule_type {
MD_PERSONALITY = 0,
diff --git a/drivers/md/raid1-10.c b/drivers/md/raid1-10.c
index 521625756128..c33099925f23 100644
--- a/drivers/md/raid1-10.c
+++ b/drivers/md/raid1-10.c
@@ -3,11 +3,6 @@
#define RESYNC_BLOCK_SIZE (64*1024)
#define RESYNC_PAGES ((RESYNC_BLOCK_SIZE + PAGE_SIZE-1) / PAGE_SIZE)
-/*
- * Number of guaranteed raid bios in case of extreme VM load:
- */
-#define NR_RAID_BIOS 256
-
/* when we get a read error on a read-only array, we redirect to another
* device without failing the first device, or trying to over-write to
* correct the read error. To keep track of bad blocks on a per-bio
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 37325a053fb4..b250c6c9e72b 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -6084,13 +6084,13 @@ static sector_t raid5_bio_lowest_chunk_sector(struct r5conf *conf,
static bool raid5_make_request(struct mddev *mddev, struct bio * bi)
{
DEFINE_WAIT_FUNC(wait, woken_wake_function);
- bool on_wq;
struct r5conf *conf = mddev->private;
- sector_t logical_sector;
- struct stripe_request_ctx ctx = {};
const int rw = bio_data_dir(bi);
+ struct stripe_request_ctx *ctx;
+ sector_t logical_sector;
enum stripe_result res;
int s, stripe_cnt;
+ bool on_wq;
if (unlikely(bi->bi_opf & REQ_PREFLUSH)) {
int ret = log_handle_flush_request(conf, bi);
@@ -6102,11 +6102,6 @@ static bool raid5_make_request(struct mddev *mddev, struct bio * bi)
return true;
}
/* ret == -EAGAIN, fallback */
- /*
- * if r5l_handle_flush_request() didn't clear REQ_PREFLUSH,
- * we need to flush journal device
- */
- ctx.do_flush = bi->bi_opf & REQ_PREFLUSH;
}
md_write_start(mddev, bi);
@@ -6129,16 +6124,25 @@ static bool raid5_make_request(struct mddev *mddev, struct bio * bi)
}
logical_sector = bi->bi_iter.bi_sector & ~((sector_t)RAID5_STRIPE_SECTORS(conf)-1);
- ctx.first_sector = logical_sector;
- ctx.last_sector = bio_end_sector(bi);
bi->bi_next = NULL;
- stripe_cnt = DIV_ROUND_UP_SECTOR_T(ctx.last_sector - logical_sector,
+ ctx = mempool_alloc(conf->ctx_pool, GFP_NOIO);
+ memset(ctx, 0, sizeof(*ctx));
+ ctx->first_sector = logical_sector;
+ ctx->last_sector = bio_end_sector(bi);
+ /*
+ * if r5l_handle_flush_request() didn't clear REQ_PREFLUSH,
+ * we need to flush journal device
+ */
+ if (unlikely(bi->bi_opf & REQ_PREFLUSH))
+ ctx->do_flush = true;
+
+ stripe_cnt = DIV_ROUND_UP_SECTOR_T(ctx->last_sector - logical_sector,
RAID5_STRIPE_SECTORS(conf));
- bitmap_set(ctx.sectors_to_do, 0, stripe_cnt);
+ bitmap_set(ctx->sectors_to_do, 0, stripe_cnt);
pr_debug("raid456: %s, logical %llu to %llu\n", __func__,
- bi->bi_iter.bi_sector, ctx.last_sector);
+ bi->bi_iter.bi_sector, ctx->last_sector);
/* Bail out if conflicts with reshape and REQ_NOWAIT is set */
if ((bi->bi_opf & REQ_NOWAIT) &&
@@ -6146,6 +6150,7 @@ static bool raid5_make_request(struct mddev *mddev, struct bio * bi)
bio_wouldblock_error(bi);
if (rw == WRITE)
md_write_end(mddev);
+ mempool_free(ctx, conf->ctx_pool);
return true;
}
md_account_bio(mddev, &bi);
@@ -6164,10 +6169,10 @@ static bool raid5_make_request(struct mddev *mddev, struct bio * bi)
add_wait_queue(&conf->wait_for_reshape, &wait);
on_wq = true;
}
- s = (logical_sector - ctx.first_sector) >> RAID5_STRIPE_SHIFT(conf);
+ s = (logical_sector - ctx->first_sector) >> RAID5_STRIPE_SHIFT(conf);
while (1) {
- res = make_stripe_request(mddev, conf, &ctx, logical_sector,
+ res = make_stripe_request(mddev, conf, ctx, logical_sector,
bi);
if (res == STRIPE_FAIL || res == STRIPE_WAIT_RESHAPE)
break;
@@ -6184,9 +6189,9 @@ static bool raid5_make_request(struct mddev *mddev, struct bio * bi)
* raid5_activate_delayed() from making progress
* and thus deadlocking.
*/
- if (ctx.batch_last) {
- raid5_release_stripe(ctx.batch_last);
- ctx.batch_last = NULL;
+ if (ctx->batch_last) {
+ raid5_release_stripe(ctx->batch_last);
+ ctx->batch_last = NULL;
}
wait_woken(&wait, TASK_UNINTERRUPTIBLE,
@@ -6194,21 +6199,23 @@ static bool raid5_make_request(struct mddev *mddev, struct bio * bi)
continue;
}
- s = find_next_bit_wrap(ctx.sectors_to_do, stripe_cnt, s);
+ s = find_next_bit_wrap(ctx->sectors_to_do, stripe_cnt, s);
if (s == stripe_cnt)
break;
- logical_sector = ctx.first_sector +
+ logical_sector = ctx->first_sector +
(s << RAID5_STRIPE_SHIFT(conf));
}
if (unlikely(on_wq))
remove_wait_queue(&conf->wait_for_reshape, &wait);
- if (ctx.batch_last)
- raid5_release_stripe(ctx.batch_last);
+ if (ctx->batch_last)
+ raid5_release_stripe(ctx->batch_last);
if (rw == WRITE)
md_write_end(mddev);
+
+ mempool_free(ctx, conf->ctx_pool);
if (res == STRIPE_WAIT_RESHAPE) {
md_free_cloned_bio(bi);
return false;
@@ -7376,6 +7383,9 @@ static void free_conf(struct r5conf *conf)
bioset_exit(&conf->bio_split);
kfree(conf->stripe_hashtbl);
kfree(conf->pending_data);
+
+ mempool_destroy(conf->ctx_pool);
+
kfree(conf);
}
@@ -8059,6 +8069,13 @@ static int raid5_run(struct mddev *mddev)
goto abort;
}
+ conf->ctx_pool = mempool_create_kmalloc_pool(NR_RAID_BIOS,
+ sizeof(struct stripe_request_ctx));
+ if (!conf->ctx_pool) {
+ ret = -ENOMEM;
+ goto abort;
+ }
+
ret = log_init(conf, journal_dev, raid5_has_ppl(conf));
if (ret)
goto abort;
diff --git a/drivers/md/raid5.h b/drivers/md/raid5.h
index eafc6e9ed6ee..6e3f07119fa4 100644
--- a/drivers/md/raid5.h
+++ b/drivers/md/raid5.h
@@ -690,6 +690,8 @@ struct r5conf {
struct list_head pending_list;
int pending_data_cnt;
struct r5pending_data *next_pending_data;
+
+ mempool_t *ctx_pool;
};
#if PAGE_SIZE == DEFAULT_STRIPE_SIZE
--
2.51.0
^ permalink raw reply related
* [PATCH v5 04/12] md: merge mddev serialize_policy into mddev_flags
From: Yu Kuai @ 2026-01-14 17:12 UTC (permalink / raw)
To: linux-raid; +Cc: yukuai, linan122, xni, dan.carpenter
In-Reply-To: <20260114171241.3043364-1-yukuai@fnnas.com>
There is not need to use a separate field in struct mddev, there are no
functional changes.
Signed-off-by: Yu Kuai <yukuai@fnnas.com>
Reviewed-by: Li Nan <linan122@huawei.com>
---
drivers/md/md-bitmap.c | 4 ++--
drivers/md/md.c | 20 ++++++++++++--------
drivers/md/md.h | 4 ++--
drivers/md/raid0.c | 3 ++-
drivers/md/raid1.c | 4 ++--
drivers/md/raid5.c | 3 ++-
6 files changed, 22 insertions(+), 16 deletions(-)
diff --git a/drivers/md/md-bitmap.c b/drivers/md/md-bitmap.c
index 84b7e2af6dba..dbe4c4b9a1da 100644
--- a/drivers/md/md-bitmap.c
+++ b/drivers/md/md-bitmap.c
@@ -2085,7 +2085,7 @@ static void bitmap_destroy(struct mddev *mddev)
return;
bitmap_wait_behind_writes(mddev);
- if (!mddev->serialize_policy)
+ if (!test_bit(MD_SERIALIZE_POLICY, &mddev->flags))
mddev_destroy_serial_pool(mddev, NULL);
mutex_lock(&mddev->bitmap_info.mutex);
@@ -2809,7 +2809,7 @@ backlog_store(struct mddev *mddev, const char *buf, size_t len)
mddev->bitmap_info.max_write_behind = backlog;
if (!backlog && mddev->serial_info_pool) {
/* serial_info_pool is not needed if backlog is zero */
- if (!mddev->serialize_policy)
+ if (!test_bit(MD_SERIALIZE_POLICY, &mddev->flags))
mddev_destroy_serial_pool(mddev, NULL);
} else if (backlog && !mddev->serial_info_pool) {
/* serial_info_pool is needed since backlog is not zero */
diff --git a/drivers/md/md.c b/drivers/md/md.c
index be0d33fbf988..21b0bc3088d2 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -279,7 +279,8 @@ void mddev_destroy_serial_pool(struct mddev *mddev, struct md_rdev *rdev)
rdev_for_each(temp, mddev) {
if (!rdev) {
- if (!mddev->serialize_policy ||
+ if (!test_bit(MD_SERIALIZE_POLICY,
+ &mddev->flags) ||
!rdev_need_serial(temp))
rdev_uninit_serial(temp);
else
@@ -5898,11 +5899,12 @@ static ssize_t serialize_policy_show(struct mddev *mddev, char *page)
if (mddev->pers == NULL || (mddev->pers->head.id != ID_RAID1))
return sprintf(page, "n/a\n");
else
- return sprintf(page, "%d\n", mddev->serialize_policy);
+ return sprintf(page, "%d\n",
+ test_bit(MD_SERIALIZE_POLICY, &mddev->flags));
}
/*
- * Setting serialize_policy to true to enforce write IO is not reordered
+ * Setting MD_SERIALIZE_POLICY enforce write IO is not reordered
* for raid1.
*/
static ssize_t
@@ -5915,7 +5917,7 @@ serialize_policy_store(struct mddev *mddev, const char *buf, size_t len)
if (err)
return err;
- if (value == mddev->serialize_policy)
+ if (value == test_bit(MD_SERIALIZE_POLICY, &mddev->flags))
return len;
err = mddev_suspend_and_lock(mddev);
@@ -5927,11 +5929,13 @@ serialize_policy_store(struct mddev *mddev, const char *buf, size_t len)
goto unlock;
}
- if (value)
+ if (value) {
mddev_create_serial_pool(mddev, NULL);
- else
+ set_bit(MD_SERIALIZE_POLICY, &mddev->flags);
+ } else {
mddev_destroy_serial_pool(mddev, NULL);
- mddev->serialize_policy = value;
+ clear_bit(MD_SERIALIZE_POLICY, &mddev->flags);
+ }
unlock:
mddev_unlock_and_resume(mddev);
return err ?: len;
@@ -6828,7 +6832,7 @@ static void __md_stop_writes(struct mddev *mddev)
md_update_sb(mddev, 1);
}
/* disable policy to guarantee rdevs free resources for serialization */
- mddev->serialize_policy = 0;
+ clear_bit(MD_SERIALIZE_POLICY, &mddev->flags);
mddev_destroy_serial_pool(mddev, NULL);
}
diff --git a/drivers/md/md.h b/drivers/md/md.h
index 297a104fba88..6ee18045f41c 100644
--- a/drivers/md/md.h
+++ b/drivers/md/md.h
@@ -342,6 +342,7 @@ struct md_cluster_operations;
* @MD_DELETED: This device is being deleted
* @MD_HAS_SUPERBLOCK: There is persistence sb in member disks.
* @MD_FAILLAST_DEV: Allow last rdev to be removed.
+ * @MD_SERIALIZE_POLICY: Enforce write IO is not reordered, just used by raid1.
*
* change UNSUPPORTED_MDDEV_FLAGS for each array type if new flag is added
*/
@@ -360,6 +361,7 @@ enum mddev_flags {
MD_DELETED,
MD_HAS_SUPERBLOCK,
MD_FAILLAST_DEV,
+ MD_SERIALIZE_POLICY,
};
enum mddev_sb_flags {
@@ -626,8 +628,6 @@ struct mddev {
/* The sequence number for sync thread */
atomic_t sync_seq;
-
- bool serialize_policy:1;
};
enum recovery_flags {
diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index 4d567fcf6a7c..d83b2b1c0049 100644
--- a/drivers/md/raid0.c
+++ b/drivers/md/raid0.c
@@ -28,7 +28,8 @@ module_param(default_layout, int, 0644);
(1L << MD_FAILFAST_SUPPORTED) |\
(1L << MD_HAS_PPL) | \
(1L << MD_HAS_MULTIPLE_PPLS) | \
- (1L << MD_FAILLAST_DEV))
+ (1L << MD_FAILLAST_DEV) | \
+ (1L << MD_SERIALIZE_POLICY))
/*
* inform the user of the raid configuration
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 98b5c93810bb..f4c7004888af 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -542,7 +542,7 @@ static void raid1_end_write_request(struct bio *bio)
call_bio_endio(r1_bio);
}
}
- } else if (rdev->mddev->serialize_policy)
+ } else if (test_bit(MD_SERIALIZE_POLICY, &rdev->mddev->flags))
remove_serial(rdev, lo, hi);
if (r1_bio->bios[mirror] == NULL)
rdev_dec_pending(rdev, conf->mddev);
@@ -1644,7 +1644,7 @@ static void raid1_write_request(struct mddev *mddev, struct bio *bio,
mbio = bio_alloc_clone(rdev->bdev, bio, GFP_NOIO,
&mddev->bio_set);
- if (mddev->serialize_policy)
+ if (test_bit(MD_SERIALIZE_POLICY, &mddev->flags))
wait_for_serialization(rdev, r1_bio);
}
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index e6a399c52ea0..37325a053fb4 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -58,7 +58,8 @@
#define UNSUPPORTED_MDDEV_FLAGS \
((1L << MD_FAILFAST_SUPPORTED) | \
- (1L << MD_FAILLAST_DEV))
+ (1L << MD_FAILLAST_DEV) | \
+ (1L << MD_SERIALIZE_POLICY))
#define cpu_to_group(cpu) cpu_to_node(cpu)
--
2.51.0
^ permalink raw reply related
* [PATCH v5 03/12] md: merge mddev faillast_dev into mddev_flags
From: Yu Kuai @ 2026-01-14 17:12 UTC (permalink / raw)
To: linux-raid; +Cc: yukuai, linan122, xni, dan.carpenter
In-Reply-To: <20260114171241.3043364-1-yukuai@fnnas.com>
There is not need to use a separate field in struct mddev, there are no
functional changes.
Signed-off-by: Yu Kuai <yukuai@fnnas.com>
Reviewed-by: Li Nan <linan122@huawei.com>
---
drivers/md/md.c | 10 ++++++----
drivers/md/md.h | 3 ++-
drivers/md/raid0.c | 3 ++-
drivers/md/raid1.c | 4 ++--
drivers/md/raid10.c | 4 ++--
drivers/md/raid5.c | 5 ++++-
6 files changed, 18 insertions(+), 11 deletions(-)
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 91a30ed6b01e..be0d33fbf988 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -5865,11 +5865,11 @@ __ATTR(consistency_policy, S_IRUGO | S_IWUSR, consistency_policy_show,
static ssize_t fail_last_dev_show(struct mddev *mddev, char *page)
{
- return sprintf(page, "%d\n", mddev->fail_last_dev);
+ return sprintf(page, "%d\n", test_bit(MD_FAILLAST_DEV, &mddev->flags));
}
/*
- * Setting fail_last_dev to true to allow last device to be forcibly removed
+ * Setting MD_FAILLAST_DEV to allow last device to be forcibly removed
* from RAID1/RAID10.
*/
static ssize_t
@@ -5882,8 +5882,10 @@ fail_last_dev_store(struct mddev *mddev, const char *buf, size_t len)
if (ret)
return ret;
- if (value != mddev->fail_last_dev)
- mddev->fail_last_dev = value;
+ if (value)
+ set_bit(MD_FAILLAST_DEV, &mddev->flags);
+ else
+ clear_bit(MD_FAILLAST_DEV, &mddev->flags);
return len;
}
diff --git a/drivers/md/md.h b/drivers/md/md.h
index b4c9aa600edd..297a104fba88 100644
--- a/drivers/md/md.h
+++ b/drivers/md/md.h
@@ -341,6 +341,7 @@ struct md_cluster_operations;
* @MD_BROKEN: This is used to stop writes and mark array as failed.
* @MD_DELETED: This device is being deleted
* @MD_HAS_SUPERBLOCK: There is persistence sb in member disks.
+ * @MD_FAILLAST_DEV: Allow last rdev to be removed.
*
* change UNSUPPORTED_MDDEV_FLAGS for each array type if new flag is added
*/
@@ -358,6 +359,7 @@ enum mddev_flags {
MD_DO_DELETE,
MD_DELETED,
MD_HAS_SUPERBLOCK,
+ MD_FAILLAST_DEV,
};
enum mddev_sb_flags {
@@ -625,7 +627,6 @@ struct mddev {
/* The sequence number for sync thread */
atomic_t sync_seq;
- bool fail_last_dev:1;
bool serialize_policy:1;
};
diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index 985c377356eb..4d567fcf6a7c 100644
--- a/drivers/md/raid0.c
+++ b/drivers/md/raid0.c
@@ -27,7 +27,8 @@ module_param(default_layout, int, 0644);
(1L << MD_JOURNAL_CLEAN) | \
(1L << MD_FAILFAST_SUPPORTED) |\
(1L << MD_HAS_PPL) | \
- (1L << MD_HAS_MULTIPLE_PPLS))
+ (1L << MD_HAS_MULTIPLE_PPLS) | \
+ (1L << MD_FAILLAST_DEV))
/*
* inform the user of the raid configuration
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 57d50465eed1..98b5c93810bb 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -1746,7 +1746,7 @@ static void raid1_status(struct seq_file *seq, struct mddev *mddev)
* - &mddev->degraded is bumped.
*
* @rdev is marked as &Faulty excluding case when array is failed and
- * &mddev->fail_last_dev is off.
+ * MD_FAILLAST_DEV is not set.
*/
static void raid1_error(struct mddev *mddev, struct md_rdev *rdev)
{
@@ -1759,7 +1759,7 @@ static void raid1_error(struct mddev *mddev, struct md_rdev *rdev)
(conf->raid_disks - mddev->degraded) == 1) {
set_bit(MD_BROKEN, &mddev->flags);
- if (!mddev->fail_last_dev) {
+ if (!test_bit(MD_FAILLAST_DEV, &mddev->flags)) {
conf->recovery_disabled = mddev->recovery_disabled;
spin_unlock_irqrestore(&conf->device_lock, flags);
return;
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 84be4cc7e873..09328e032f14 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -1990,7 +1990,7 @@ static int enough(struct r10conf *conf, int ignore)
* - &mddev->degraded is bumped.
*
* @rdev is marked as &Faulty excluding case when array is failed and
- * &mddev->fail_last_dev is off.
+ * MD_FAILLAST_DEV is not set.
*/
static void raid10_error(struct mddev *mddev, struct md_rdev *rdev)
{
@@ -2002,7 +2002,7 @@ static void raid10_error(struct mddev *mddev, struct md_rdev *rdev)
if (test_bit(In_sync, &rdev->flags) && !enough(conf, rdev->raid_disk)) {
set_bit(MD_BROKEN, &mddev->flags);
- if (!mddev->fail_last_dev) {
+ if (!test_bit(MD_FAILLAST_DEV, &mddev->flags)) {
spin_unlock_irqrestore(&conf->device_lock, flags);
return;
}
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 39bec4d199a1..e6a399c52ea0 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -56,7 +56,10 @@
#include "md-bitmap.h"
#include "raid5-log.h"
-#define UNSUPPORTED_MDDEV_FLAGS (1L << MD_FAILFAST_SUPPORTED)
+#define UNSUPPORTED_MDDEV_FLAGS \
+ ((1L << MD_FAILFAST_SUPPORTED) | \
+ (1L << MD_FAILLAST_DEV))
+
#define cpu_to_group(cpu) cpu_to_node(cpu)
#define ANY_GROUP NUMA_NO_NODE
--
2.51.0
^ permalink raw reply related
* [PATCH v5 02/12] md: merge mddev has_superblock into mddev_flags
From: Yu Kuai @ 2026-01-14 17:12 UTC (permalink / raw)
To: linux-raid; +Cc: yukuai, linan122, xni, dan.carpenter
In-Reply-To: <20260114171241.3043364-1-yukuai@fnnas.com>
There is not need to use a separate field in struct mddev, there are no
functional changes.
Signed-off-by: Yu Kuai <yukuai@fnnas.com>
Reviewed-by: Li Nan <linan122@huawei.com>
---
drivers/md/md.c | 6 +++---
drivers/md/md.h | 3 ++-
2 files changed, 5 insertions(+), 4 deletions(-)
diff --git a/drivers/md/md.c b/drivers/md/md.c
index e5922a682953..91a30ed6b01e 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -6463,7 +6463,7 @@ int md_run(struct mddev *mddev)
* the only valid external interface is through the md
* device.
*/
- mddev->has_superblocks = false;
+ clear_bit(MD_HAS_SUPERBLOCK, &mddev->flags);
rdev_for_each(rdev, mddev) {
if (test_bit(Faulty, &rdev->flags))
continue;
@@ -6476,7 +6476,7 @@ int md_run(struct mddev *mddev)
}
if (rdev->sb_page)
- mddev->has_superblocks = true;
+ set_bit(MD_HAS_SUPERBLOCK, &mddev->flags);
/* perform some consistency tests on the device.
* We don't want the data to overlap the metadata,
@@ -9086,7 +9086,7 @@ void md_write_start(struct mddev *mddev, struct bio *bi)
rcu_read_unlock();
if (did_change)
sysfs_notify_dirent_safe(mddev->sysfs_state);
- if (!mddev->has_superblocks)
+ if (!test_bit(MD_HAS_SUPERBLOCK, &mddev->flags))
return;
wait_event(mddev->sb_wait,
!test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags));
diff --git a/drivers/md/md.h b/drivers/md/md.h
index 6985f2829bbd..b4c9aa600edd 100644
--- a/drivers/md/md.h
+++ b/drivers/md/md.h
@@ -340,6 +340,7 @@ struct md_cluster_operations;
* array is ready yet.
* @MD_BROKEN: This is used to stop writes and mark array as failed.
* @MD_DELETED: This device is being deleted
+ * @MD_HAS_SUPERBLOCK: There is persistence sb in member disks.
*
* change UNSUPPORTED_MDDEV_FLAGS for each array type if new flag is added
*/
@@ -356,6 +357,7 @@ enum mddev_flags {
MD_BROKEN,
MD_DO_DELETE,
MD_DELETED,
+ MD_HAS_SUPERBLOCK,
};
enum mddev_sb_flags {
@@ -623,7 +625,6 @@ struct mddev {
/* The sequence number for sync thread */
atomic_t sync_seq;
- bool has_superblocks:1;
bool fail_last_dev:1;
bool serialize_policy:1;
};
--
2.51.0
^ permalink raw reply related
* [PATCH v5 01/12] md/raid5: fix raid5_run() to return error when log_init() fails
From: Yu Kuai @ 2026-01-14 17:12 UTC (permalink / raw)
To: linux-raid; +Cc: yukuai, linan122, xni, dan.carpenter
In-Reply-To: <20260114171241.3043364-1-yukuai@fnnas.com>
Since commit f63f17350e53 ("md/raid5: use the atomic queue limit
update APIs"), the abort path in raid5_run() returns 'ret' instead of
-EIO. However, if log_init() fails, 'ret' is still 0 from the previous
successful call, causing raid5_run() to return success despite the
failure.
Fix this by capturing the return value from log_init().
Fixes: f63f17350e53 ("md/raid5: use the atomic queue limit update APIs")
Reported-by: Dan Carpenter <dan.carpenter@linaro.org>
Closes: https://lore.kernel.org/r/202601130531.LGfcZsa4-lkp@intel.com/
Signed-off-by: Yu Kuai <yukuai3@huawei.com>
---
drivers/md/raid5.c | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index e57ce3295292..39bec4d199a1 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -8055,7 +8055,8 @@ static int raid5_run(struct mddev *mddev)
goto abort;
}
- if (log_init(conf, journal_dev, raid5_has_ppl(conf)))
+ ret = log_init(conf, journal_dev, raid5_has_ppl(conf));
+ if (ret)
goto abort;
return 0;
--
2.51.0
^ permalink raw reply related
* [PATCH v5 00/12] md: align bio to io_opt for better performance
From: Yu Kuai @ 2026-01-14 17:12 UTC (permalink / raw)
To: linux-raid; +Cc: yukuai, linan122, xni, dan.carpenter
This patchset optimizes MD RAID performance by aligning bios to the
optimal I/O size before splitting. When I/O is aligned to io_opt,
raid5 can perform full stripe writes without needing to read extra
data for parity calculation, significantly improving bandwidth.
Patch 1: Fix a bug in raid5_run() error handling
Patches 2-4: Cleanup - merge boolean fields into mddev_flags
Patches 5-6: Preparation - use mempool for stripe_request_ctx and
ensure max_sectors >= io_opt
Patches 7-8: Core - add bio alignment infrastructure
Patches 9-11: Enable bio alignment for raid5, raid10, and raid0
Patch 12: Fix abnormal io_opt from member disks
Performance improvement on 32-disk raid5 with 64kb chunk:
dd if=/dev/zero of=/dev/md0 bs=100M oflag=direct
Before: 782 MB/s
After: 1.1 GB/s
Changes in v5:
- Add patch 1 to fix raid5_run() returning success when log_init() fails
- Patch 12: Fix stale commit message (remove mention of MD_STACK_IO_OPT flag)
Changes in v4:
- Patch 12: Simplify by checking rdev_is_mddev() first, remove
MD_STACK_IO_OPT flag
Changes in v3:
- Patch 5: Remove unnecessary NULL check before mempool_destroy()
- Patch 7: Use sector_div() instead of roundup()/rounddown() to fix
64-bit division issue on 32-bit platforms
Changes in v2:
- Fix mempool in patch 5
- Add prep cleanup patches, 2-4
- Add patch 12 to fix abnormal io_opt
- Add Link tags to patches
Yu Kuai (12):
md/raid5: fix raid5_run() to return error when log_init() fails
md: merge mddev has_superblock into mddev_flags
md: merge mddev faillast_dev into mddev_flags
md: merge mddev serialize_policy into mddev_flags
md/raid5: use mempool to allocate stripe_request_ctx
md/raid5: make sure max_sectors is not less than io_opt
md: support to align bio to limits
md: add a helper md_config_align_limits()
md/raid5: align bio to io_opt
md/raid10: align bio to io_opt
md/raid0: align bio to io_opt
md: fix abnormal io_opt from member disks
drivers/md/md-bitmap.c | 4 +-
drivers/md/md.c | 118 +++++++++++++++++++++++++++++++++++------
drivers/md/md.h | 30 +++++++++--
drivers/md/raid0.c | 6 ++-
drivers/md/raid1-10.c | 5 --
drivers/md/raid1.c | 13 ++---
drivers/md/raid10.c | 10 ++--
drivers/md/raid5.c | 95 +++++++++++++++++++++++----------
drivers/md/raid5.h | 3 ++
9 files changed, 217 insertions(+), 67 deletions(-)
--
2.51.0
^ permalink raw reply
* Re: [RFC PATCH 2/2] swsusp: make it possible to hibernate to device mapper devices
From: Askar Safin @ 2026-01-14 7:27 UTC (permalink / raw)
To: mpatocka
Cc: Dell.Client.Kernel, agk, brauner, dm-devel, ebiggers, kix,
linux-block, linux-btrfs, linux-crypto, linux-lvm, linux-mm,
linux-pm, linux-raid, lvm-devel, milan, msnitzer, mzxreary,
nphamcs, pavel, rafael, ryncsn, torvalds
In-Reply-To: <b32d0701-4399-9c5d-ecc8-071162df97a7@redhat.com>
Mikulas Patocka <mpatocka@redhat.com>:
> Askar Safin requires swap and hibernation on the dm-integrity device mapper
> target because he needs to protect his data.
Now I see that your approach is valid. (But some small changes are needed.)
[[ TL;DR: you approach is good. I kindly ask you to continue with this patch.
Needed changes are in section "Needed changes". ]]
Let me explain why I initially rejected your patch and why now I think it is good.
= Why I rejected =
In your patch "notify_swap_device" call located before "pm_restrict_gfp_mask".
But "pm_restrict_gfp_mask" is call, which forbids further swapping. I. e.
we still can swap till "pm_restrict_gfp_mask" call!
Thus "notify_swap_device" should be moved after "pm_restrict_gfp_mask" call.
But then I thought about more complex storage hierarchies. For example,
swap on top of some dm device on top of loop device on top of some filesystem
on top of some another dm device, etc.
If we have such hierarchy, then hibernating dm devices should be intertwined
with freezing of filesystems, which happens in "filesystems_freeze" call.
But "filesystems_freeze" call located before "pm_restrict_gfp_mask" call, so
here we got contradiction.
In other words, we should satisfy this 3 things at the same time:
- Hibernating of dm devices should happen inside "filesystems_freeze" call
intermixed with freezing of filesystems
- Hibernating of dm devices should happen after "pm_restrict_gfp_mask" call
- "pm_restrict_gfp_mask" is located after "filesystems_freeze" call in current
kernel
These 3 points obviously contradict to each other.
So in this point I gave up.
The only remaining solution (as I thought at that time) was to move
"filesystems_freeze" after "pm_restrict_gfp_mask" call (or to move
"pm_restrict_gfp_mask" before "filesystems_freeze").
But:
- Freezing of filesystem might require memory. It is bad idea to call
"filesystems_freeze" after we forbid to swap
- This would be pretty big change to the kernel. I'm not sure that my
small use case justifies such change
So in this point I totally gave up.
= Why now I think your patch is good =
But then I found this your email:
https://lore.kernel.org/all/3f3d871a-6a86-354f-f83d-a871793a4a47@redhat.com/ .
And now I see that complex hierarchies, such as described above, are not
supported anyway!
This fully ruins my argument above.
And this means that your patch in fact works!
= Needed changes =
Please, move "notify_swap_device" after "pm_restrict_gfp_mask".
Also: you introduced new operation to target_type: hibernate.
I'm not sure we need this operation, we already have presuspend
and postsuspend. In my personal hacky patch I simply added
"dm_bufio_client_reset" to the end of "dm_integrity_postsuspend",
and it worked. But I'm not sure about this point, i. e. if
you think that we need "hibernate", then go with it.
--
Askar Safin
^ permalink raw reply
* Re: [PATCH v4 11/11] md: fix abnormal io_opt from member disks
From: Xiao Ni @ 2026-01-14 3:15 UTC (permalink / raw)
To: Yu Kuai; +Cc: linux-raid, linan122
In-Reply-To: <20260112042857.2334264-12-yukuai@fnnas.com>
On Mon, Jan 12, 2026 at 12:30 PM Yu Kuai <yukuai@fnnas.com> wrote:
>
> It's reported that mtp3sas can report abnormal io_opt, for consequence,
> md array will end up with abnormal io_opt as well, due to the
> lcm_not_zero() from blk_stack_limits().
>
> Some personalities will configure optimal IO size, and it's indicate that
> users can get the best IO bandwidth if they issue IO with this size, and
> we don't want io_opt to be covered by member disks with abnormal io_opt.
>
> Fix this problem by adding a new mddev flags MD_STACK_IO_OPT to indicate
> that io_opt configured by personalities is preferred over member disks
> or not.
Hi Kuai
In v4, it doesn't use MD_STACK_IO_OPT anymore. So the comment needs to
be modified.
The patch looks good to me.
Reviewed-by: Xiao Ni <xni@redhat.com>
>
> Reported-by: Filippo Giunchedi <filippo@debian.org>
> Closes: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=1121006
> Reported-by: Coly Li <colyli@fnnas.com>
> Closes: https://lore.kernel.org/all/20250817152645.7115-1-colyli@kernel.org/
> Signed-off-by: Yu Kuai <yukuai@fnnas.com>
> ---
> drivers/md/md.c | 28 +++++++++++++++++++++++++++-
> drivers/md/md.h | 3 ++-
> drivers/md/raid1.c | 2 +-
> drivers/md/raid10.c | 4 ++--
> 4 files changed, 32 insertions(+), 5 deletions(-)
>
> diff --git a/drivers/md/md.c b/drivers/md/md.c
> index 731ec800f5cb..6c0fb09c26dc 100644
> --- a/drivers/md/md.c
> +++ b/drivers/md/md.c
> @@ -6200,18 +6200,33 @@ static const struct kobj_type md_ktype = {
>
> int mdp_major = 0;
>
> +static bool rdev_is_mddev(struct md_rdev *rdev)
> +{
> + return rdev->bdev->bd_disk->fops == &md_fops;
> +}
> +
> /* stack the limit for all rdevs into lim */
> int mddev_stack_rdev_limits(struct mddev *mddev, struct queue_limits *lim,
> unsigned int flags)
> {
> struct md_rdev *rdev;
> + bool io_opt_configured = lim->io_opt;
>
> rdev_for_each(rdev, mddev) {
> + unsigned int io_opt = lim->io_opt;
> +
> queue_limits_stack_bdev(lim, rdev->bdev, rdev->data_offset,
> mddev->gendisk->disk_name);
> if ((flags & MDDEV_STACK_INTEGRITY) &&
> !queue_limits_stack_integrity_bdev(lim, rdev->bdev))
> return -EINVAL;
> +
> + /*
> + * If member disk is not mdraid array, keep the io_opt
> + * from personality and ignore io_opt from member disk.
> + */
> + if (!rdev_is_mddev(rdev) && io_opt_configured)
> + lim->io_opt = io_opt;
> }
>
> /*
> @@ -6230,9 +6245,11 @@ int mddev_stack_rdev_limits(struct mddev *mddev, struct queue_limits *lim,
> EXPORT_SYMBOL_GPL(mddev_stack_rdev_limits);
>
> /* apply the extra stacking limits from a new rdev into mddev */
> -int mddev_stack_new_rdev(struct mddev *mddev, struct md_rdev *rdev)
> +int mddev_stack_new_rdev(struct mddev *mddev, struct md_rdev *rdev,
> + bool io_opt_configured)
> {
> struct queue_limits lim;
> + unsigned int io_opt;
>
> if (mddev_is_dm(mddev))
> return 0;
> @@ -6245,6 +6262,8 @@ int mddev_stack_new_rdev(struct mddev *mddev, struct md_rdev *rdev)
> }
>
> lim = queue_limits_start_update(mddev->gendisk->queue);
> + io_opt = lim.io_opt;
> +
> queue_limits_stack_bdev(&lim, rdev->bdev, rdev->data_offset,
> mddev->gendisk->disk_name);
>
> @@ -6255,6 +6274,13 @@ int mddev_stack_new_rdev(struct mddev *mddev, struct md_rdev *rdev)
> return -ENXIO;
> }
>
> + /*
> + * If member disk is not mdraid array, keep the io_opt from
> + * personality and ignore io_opt from member disk.
> + */
> + if (!rdev_is_mddev(rdev) && io_opt_configured)
> + lim.io_opt = io_opt;
> +
> return queue_limits_commit_update(mddev->gendisk->queue, &lim);
> }
> EXPORT_SYMBOL_GPL(mddev_stack_new_rdev);
> diff --git a/drivers/md/md.h b/drivers/md/md.h
> index ddf989f2a139..80c527b3777d 100644
> --- a/drivers/md/md.h
> +++ b/drivers/md/md.h
> @@ -1041,7 +1041,8 @@ int do_md_run(struct mddev *mddev);
> #define MDDEV_STACK_INTEGRITY (1u << 0)
> int mddev_stack_rdev_limits(struct mddev *mddev, struct queue_limits *lim,
> unsigned int flags);
> -int mddev_stack_new_rdev(struct mddev *mddev, struct md_rdev *rdev);
> +int mddev_stack_new_rdev(struct mddev *mddev, struct md_rdev *rdev,
> + bool io_opt_configured);
> void mddev_update_io_opt(struct mddev *mddev, unsigned int nr_stripes);
>
> extern const struct block_device_operations md_fops;
> diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
> index 1a957dba2640..f3f3086f27fa 100644
> --- a/drivers/md/raid1.c
> +++ b/drivers/md/raid1.c
> @@ -1944,7 +1944,7 @@ static int raid1_add_disk(struct mddev *mddev, struct md_rdev *rdev)
> for (mirror = first; mirror <= last; mirror++) {
> p = conf->mirrors + mirror;
> if (!p->rdev) {
> - err = mddev_stack_new_rdev(mddev, rdev);
> + err = mddev_stack_new_rdev(mddev, rdev, false);
> if (err)
> return err;
>
> diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
> index 2c6b65b83724..a6edc91e7a9a 100644
> --- a/drivers/md/raid10.c
> +++ b/drivers/md/raid10.c
> @@ -2139,7 +2139,7 @@ static int raid10_add_disk(struct mddev *mddev, struct md_rdev *rdev)
> continue;
> }
>
> - err = mddev_stack_new_rdev(mddev, rdev);
> + err = mddev_stack_new_rdev(mddev, rdev, true);
> if (err)
> return err;
> p->head_position = 0;
> @@ -2157,7 +2157,7 @@ static int raid10_add_disk(struct mddev *mddev, struct md_rdev *rdev)
> clear_bit(In_sync, &rdev->flags);
> set_bit(Replacement, &rdev->flags);
> rdev->raid_disk = repl_slot;
> - err = mddev_stack_new_rdev(mddev, rdev);
> + err = mddev_stack_new_rdev(mddev, rdev, true);
> if (err)
> return err;
> conf->fullsync = 1;
> --
> 2.51.0
>
>
^ permalink raw reply
* Re: [RFC PATCH 5/5] md/raid1: introduce rectify action to repair badblocks
From: Li Nan @ 2026-01-14 3:11 UTC (permalink / raw)
To: Zheng Qixing, song, yukuai
Cc: linux-raid, linux-kernel, yi.zhang, yangerkun, houtao1,
zhengqixing, linan122
In-Reply-To: <20251231070952.1233903-6-zhengqixing@huaweicloud.com>
在 2025/12/31 15:09, Zheng Qixing 写道:
> From: Zheng Qixing <zhengqixing@huawei.com>
>
> Add support for repairing known badblocks in RAID1. When disks
> have known badblocks (shown in sysfs bad_blocks), data can be
> read from other healthy disks in the array and written to repair
> the badblock areas and clear it in bad_blocks.
>
> echo rectify > sync_action can trigger this action.
>
> Signed-off-by: Zheng Qixing <zhengqixing@huawei.com>
> +static void end_rectify_read(struct bio *bio)
> +{
> + struct r1bio *r1_bio = get_resync_r1bio(bio);
> + struct r1conf *conf = r1_bio->mddev->private;
> + struct md_rdev *rdev;
> + struct bio *next_bio;
> + bool all_fail = true;
> + int i;
> +
> + update_head_pos(r1_bio->read_disk, r1_bio);
> +
> + if (!bio->bi_status) {
> + set_bit(R1BIO_Uptodate, &r1_bio->state);
> + goto out;
> + }
> +
> + for (i = r1_bio->read_disk + 1; i < conf->raid_disks; i++) {
> + rdev = conf->mirrors[i].rdev;
> + if (!rdev || test_bit(Faulty, &rdev->flags))
> + continue;
> +
> + next_bio = r1_bio->bios[i];
> + if (next_bio->bi_end_io == end_rectify_read) {
> + next_bio->bi_opf &= ~MD_FAILFAST;
Why set MD_FAILFAST and clear it soon?
And submit_rectify_read() will clear it again.
> +static void rectify_request_write(struct mddev *mddev, struct r1bio *r1_bio)
> +{
> + struct r1conf *conf = mddev->private;
> + struct bio *wbio = NULL;
> + int wcnt = 0;
> + int i;
> +
> + if (!test_bit(R1BIO_Uptodate, &r1_bio->state)) {
> + submit_rectify_read(r1_bio);
> + return;
> + }
> +
> + atomic_set(&r1_bio->remaining, 0);
> + for (i = 0; i < conf->raid_disks; i++) {
> + wbio = r1_bio->bios[i];
> + if (wbio->bi_end_io == end_rectify_write) {
> + atomic_inc(&r1_bio->remaining);
> + wcnt++;
> + submit_bio_noacct(wbio);
> + }
> + }
> +
> + if (unlikely(!wcnt)) {
> + md_done_sync(r1_bio->mddev, r1_bio->sectors);
> + put_buf(r1_bio);
> + }
How can 'wcnt' be 0?
> +}
> +
> +static void handle_rectify_write_finished(struct r1conf *conf, struct r1bio *r1_bio)
> +{
> + struct md_rdev *rdev;
> + struct bio *bio;
> + int i;
> +
> + for (i = 0; i < conf->raid_disks; i++) {
> + rdev = conf->mirrors[i].rdev;
> + bio = r1_bio->bios[i];
> + if (bio->bi_end_io == NULL)
> + continue;
> +
> + if (!bio->bi_status && bio->bi_end_io == end_rectify_write &&
> + test_bit(R1BIO_MadeGood, &r1_bio->state)) {
> + rdev_clear_badblocks(rdev, r1_bio->sector,
> + r1_bio->sectors, 0);
> + }
Reuse handle_sync_write_finished() seems better.
> + }
> +
> + md_done_sync(r1_bio->mddev, r1_bio->sectors);
> + put_buf(r1_bio);
> +}
> +
--
Thanks,
Nan
^ permalink raw reply
* Re: [PATCH v4 05/11] md/raid5: make sure max_sectors is not less than io_opt
From: Yu Kuai @ 2026-01-13 6:11 UTC (permalink / raw)
To: Dan Carpenter, oe-kbuild, linux-raid, linan122, yukuai; +Cc: lkp, oe-kbuild-all
In-Reply-To: <202601130531.LGfcZsa4-lkp@intel.com>
Hi,
在 2026/1/13 13:06, Dan Carpenter 写道:
> Hi Yu,
>
> kernel test robot noticed the following build warnings:
>
> https://git-scm.com/docs/git-format-patch#_base_tree_information]
>
> url: https://github.com/intel-lab-lkp/linux/commits/Yu-Kuai/md-merge-mddev-has_superblock-into-mddev_flags/20260112-123233
> base: linus/master
> patch link: https://lore.kernel.org/r/20260112042857.2334264-6-yukuai%40fnnas.com
> patch subject: [PATCH v4 05/11] md/raid5: make sure max_sectors is not less than io_opt
> config: i386-randconfig-141-20260113 (https://download.01.org/0day-ci/archive/20260113/202601130531.LGfcZsa4-lkp@intel.com/config)
> compiler: gcc-14 (Debian 14.2.0-19) 14.2.0
> smatch version: v0.5.0-8985-g2614ff1a
>
> If you fix the issue in a separate patch/commit (i.e. not just a new version of
> the same patch/commit), kindly add following tags
> | Reported-by: kernel test robot <lkp@intel.com>
> | Reported-by: Dan Carpenter <dan.carpenter@linaro.org>
> | Closes: https://lore.kernel.org/r/202601130531.LGfcZsa4-lkp@intel.com/
>
> New smatch warnings:
> drivers/md/raid5.c:8100 raid5_run() warn: missing error code 'ret'
>
> vim +/ret +8100 drivers/md/raid5.c
>
> cc6167b4f3b3ca NeilBrown 2016-11-02 8064 pr_info("md/raid:%s: raid level %d active with %d out of %d devices, algorithm %d\n",
> cc6167b4f3b3ca NeilBrown 2016-11-02 8065 mdname(mddev), conf->level,
> ^1da177e4c3f41 Linus Torvalds 2005-04-16 8066 mddev->raid_disks-mddev->degraded, mddev->raid_disks,
> e183eaedd53807 NeilBrown 2009-03-31 8067 mddev->new_layout);
> ^1da177e4c3f41 Linus Torvalds 2005-04-16 8068
> ^1da177e4c3f41 Linus Torvalds 2005-04-16 8069 print_raid5_conf(conf);
> ^1da177e4c3f41 Linus Torvalds 2005-04-16 8070
> fef9c61fdfabf9 NeilBrown 2009-03-31 8071 if (conf->reshape_progress != MaxSector) {
> fef9c61fdfabf9 NeilBrown 2009-03-31 8072 conf->reshape_safe = conf->reshape_progress;
> f67055780caac6 NeilBrown 2006-03-27 8073 atomic_set(&conf->reshape_stripes, 0);
> f67055780caac6 NeilBrown 2006-03-27 8074 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
> f67055780caac6 NeilBrown 2006-03-27 8075 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
> f67055780caac6 NeilBrown 2006-03-27 8076 set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
> ad39c08186f8a0 Yu Kuai 2024-02-01 8077 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
> f67055780caac6 NeilBrown 2006-03-27 8078 }
> f67055780caac6 NeilBrown 2006-03-27 8079
> ^1da177e4c3f41 Linus Torvalds 2005-04-16 8080 /* Ok, everything is just fine now */
> a64c876fd35790 NeilBrown 2010-04-14 8081 if (mddev->to_remove == &raid5_attrs_group)
> a64c876fd35790 NeilBrown 2010-04-14 8082 mddev->to_remove = NULL;
> 00bcb4ac7ee7e5 NeilBrown 2010-06-01 8083 else if (mddev->kobj.sd &&
> 00bcb4ac7ee7e5 NeilBrown 2010-06-01 8084 sysfs_create_group(&mddev->kobj, &raid5_attrs_group))
> cc6167b4f3b3ca NeilBrown 2016-11-02 8085 pr_warn("raid5: failed to create sysfs attributes for %s\n",
> 5e55e2f5fc95b3 NeilBrown 2007-03-26 8086 mdname(mddev));
> 4a5add49951e69 NeilBrown 2010-06-01 8087 md_set_array_sectors(mddev, raid5_size(mddev, 0, 0));
> 7a5febe9ffeecd NeilBrown 2005-05-16 8088
> 176df894d79741 Christoph Hellwig 2024-03-03 8089 if (!mddev_is_dm(mddev)) {
> f63f17350e5373 Christoph Hellwig 2024-03-03 8090 ret = raid5_set_limits(mddev);
> f63f17350e5373 Christoph Hellwig 2024-03-03 8091 if (ret)
> f63f17350e5373 Christoph Hellwig 2024-03-03 8092 goto abort;
> 9f7c2220017771 NeilBrown 2010-07-26 8093 }
> 23032a0eb97c8e Raz Ben-Jehuda(caro 2006-12-10 8094)
> 585d578974395f Yu Kuai 2026-01-12 8095 ret = raid5_create_ctx_pool(conf);
> 585d578974395f Yu Kuai 2026-01-12 8096 if (ret)
> 01fce9e38c0e92 Yu Kuai 2026-01-12 8097 goto abort;
> 01fce9e38c0e92 Yu Kuai 2026-01-12 8098
> 845b9e229fe071 Artur Paszkiewicz 2017-04-04 8099 if (log_init(conf, journal_dev, raid5_has_ppl(conf)))
> 5aabf7c49d9ebe Song Liu 2016-11-17 @8100 goto abort;
>
> Presumably we should propagate the error code from log_init()?
Yes we should, but this problem looks already exist before this patch.
>
> 5c7e81c3de9eb3 Shaohua Li 2015-08-13 8101
> ^1da177e4c3f41 Linus Torvalds 2005-04-16 8102 return 0;
> ^1da177e4c3f41 Linus Torvalds 2005-04-16 8103 abort:
> 7eb8ff02c1df27 Li Lingfeng 2023-08-03 8104 md_unregister_thread(mddev, &mddev->thread);
> ^1da177e4c3f41 Linus Torvalds 2005-04-16 8105 print_raid5_conf(conf);
> 95fc17aac45300 Dan Williams 2009-07-31 8106 free_conf(conf);
> ^1da177e4c3f41 Linus Torvalds 2005-04-16 8107 mddev->private = NULL;
> cc6167b4f3b3ca NeilBrown 2016-11-02 8108 pr_warn("md/raid:%s: failed to run raid set.\n", mdname(mddev));
> f63f17350e5373 Christoph Hellwig 2024-03-03 8109 return ret;
> ^1da177e4c3f41 Linus Torvalds 2005-04-16 8110 }
>
--
Thansk,
Kuai
^ permalink raw reply
* Re: [PATCH v4 05/11] md/raid5: make sure max_sectors is not less than io_opt
From: Dan Carpenter @ 2026-01-13 5:06 UTC (permalink / raw)
To: oe-kbuild, Yu Kuai, linux-raid, linan122; +Cc: lkp, oe-kbuild-all, yukuai
In-Reply-To: <20260112042857.2334264-6-yukuai@fnnas.com>
Hi Yu,
kernel test robot noticed the following build warnings:
https://git-scm.com/docs/git-format-patch#_base_tree_information]
url: https://github.com/intel-lab-lkp/linux/commits/Yu-Kuai/md-merge-mddev-has_superblock-into-mddev_flags/20260112-123233
base: linus/master
patch link: https://lore.kernel.org/r/20260112042857.2334264-6-yukuai%40fnnas.com
patch subject: [PATCH v4 05/11] md/raid5: make sure max_sectors is not less than io_opt
config: i386-randconfig-141-20260113 (https://download.01.org/0day-ci/archive/20260113/202601130531.LGfcZsa4-lkp@intel.com/config)
compiler: gcc-14 (Debian 14.2.0-19) 14.2.0
smatch version: v0.5.0-8985-g2614ff1a
If you fix the issue in a separate patch/commit (i.e. not just a new version of
the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <lkp@intel.com>
| Reported-by: Dan Carpenter <dan.carpenter@linaro.org>
| Closes: https://lore.kernel.org/r/202601130531.LGfcZsa4-lkp@intel.com/
New smatch warnings:
drivers/md/raid5.c:8100 raid5_run() warn: missing error code 'ret'
vim +/ret +8100 drivers/md/raid5.c
cc6167b4f3b3ca NeilBrown 2016-11-02 8064 pr_info("md/raid:%s: raid level %d active with %d out of %d devices, algorithm %d\n",
cc6167b4f3b3ca NeilBrown 2016-11-02 8065 mdname(mddev), conf->level,
^1da177e4c3f41 Linus Torvalds 2005-04-16 8066 mddev->raid_disks-mddev->degraded, mddev->raid_disks,
e183eaedd53807 NeilBrown 2009-03-31 8067 mddev->new_layout);
^1da177e4c3f41 Linus Torvalds 2005-04-16 8068
^1da177e4c3f41 Linus Torvalds 2005-04-16 8069 print_raid5_conf(conf);
^1da177e4c3f41 Linus Torvalds 2005-04-16 8070
fef9c61fdfabf9 NeilBrown 2009-03-31 8071 if (conf->reshape_progress != MaxSector) {
fef9c61fdfabf9 NeilBrown 2009-03-31 8072 conf->reshape_safe = conf->reshape_progress;
f67055780caac6 NeilBrown 2006-03-27 8073 atomic_set(&conf->reshape_stripes, 0);
f67055780caac6 NeilBrown 2006-03-27 8074 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
f67055780caac6 NeilBrown 2006-03-27 8075 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
f67055780caac6 NeilBrown 2006-03-27 8076 set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
ad39c08186f8a0 Yu Kuai 2024-02-01 8077 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
f67055780caac6 NeilBrown 2006-03-27 8078 }
f67055780caac6 NeilBrown 2006-03-27 8079
^1da177e4c3f41 Linus Torvalds 2005-04-16 8080 /* Ok, everything is just fine now */
a64c876fd35790 NeilBrown 2010-04-14 8081 if (mddev->to_remove == &raid5_attrs_group)
a64c876fd35790 NeilBrown 2010-04-14 8082 mddev->to_remove = NULL;
00bcb4ac7ee7e5 NeilBrown 2010-06-01 8083 else if (mddev->kobj.sd &&
00bcb4ac7ee7e5 NeilBrown 2010-06-01 8084 sysfs_create_group(&mddev->kobj, &raid5_attrs_group))
cc6167b4f3b3ca NeilBrown 2016-11-02 8085 pr_warn("raid5: failed to create sysfs attributes for %s\n",
5e55e2f5fc95b3 NeilBrown 2007-03-26 8086 mdname(mddev));
4a5add49951e69 NeilBrown 2010-06-01 8087 md_set_array_sectors(mddev, raid5_size(mddev, 0, 0));
7a5febe9ffeecd NeilBrown 2005-05-16 8088
176df894d79741 Christoph Hellwig 2024-03-03 8089 if (!mddev_is_dm(mddev)) {
f63f17350e5373 Christoph Hellwig 2024-03-03 8090 ret = raid5_set_limits(mddev);
f63f17350e5373 Christoph Hellwig 2024-03-03 8091 if (ret)
f63f17350e5373 Christoph Hellwig 2024-03-03 8092 goto abort;
9f7c2220017771 NeilBrown 2010-07-26 8093 }
23032a0eb97c8e Raz Ben-Jehuda(caro 2006-12-10 8094)
585d578974395f Yu Kuai 2026-01-12 8095 ret = raid5_create_ctx_pool(conf);
585d578974395f Yu Kuai 2026-01-12 8096 if (ret)
01fce9e38c0e92 Yu Kuai 2026-01-12 8097 goto abort;
01fce9e38c0e92 Yu Kuai 2026-01-12 8098
845b9e229fe071 Artur Paszkiewicz 2017-04-04 8099 if (log_init(conf, journal_dev, raid5_has_ppl(conf)))
5aabf7c49d9ebe Song Liu 2016-11-17 @8100 goto abort;
Presumably we should propagate the error code from log_init()?
5c7e81c3de9eb3 Shaohua Li 2015-08-13 8101
^1da177e4c3f41 Linus Torvalds 2005-04-16 8102 return 0;
^1da177e4c3f41 Linus Torvalds 2005-04-16 8103 abort:
7eb8ff02c1df27 Li Lingfeng 2023-08-03 8104 md_unregister_thread(mddev, &mddev->thread);
^1da177e4c3f41 Linus Torvalds 2005-04-16 8105 print_raid5_conf(conf);
95fc17aac45300 Dan Williams 2009-07-31 8106 free_conf(conf);
^1da177e4c3f41 Linus Torvalds 2005-04-16 8107 mddev->private = NULL;
cc6167b4f3b3ca NeilBrown 2016-11-02 8108 pr_warn("md/raid:%s: failed to run raid set.\n", mdname(mddev));
f63f17350e5373 Christoph Hellwig 2024-03-03 8109 return ret;
^1da177e4c3f41 Linus Torvalds 2005-04-16 8110 }
--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
^ permalink raw reply
* Re: [QUESTION] Debugging some file data corruption
From: Calvin Owens @ 2026-01-12 18:11 UTC (permalink / raw)
To: Qu Wenruo; +Cc: linux-block, linux-raid, linux-btrfs, linux-crypto
In-Reply-To: <cd54e3a7-d676-46fe-8922-bb97d4e775cc@gmx.com>
On Wednesday 11/12 at 07:32 +1030, Qu Wenruo wrote:
> 在 2025/11/12 03:31, Calvin Owens 写道:
> > Hello all,
> >
> > I'm looking for help debugging some corruption I recently encountered.
> > It happened on 6.17.0, and I'm trying to reproduce it on 6.18-rc. This
> > is not really actionable yet, I'm just looking for advice.
> >
> > After copying about 10TB of data to a btrfs+luks+mdraid1 across two 18TB
> > drives,
>
> With LUKS in the middle, it makes any corruption pattern very human
> unreadable.
>
> I guess it's not really feasible to try to reproduce the problem again since
> it has 10TiB data involved?
>
> But if you can spend a lot of time waiting for data copy, mind to try
> the following combination(s)?
>
> - btrfs on mdraid1
> - btrfs RAID1 on raw two HDDs
I re-ran the copies several times and never reproduced it. But I finally
hit it again after I gave up, while making a backup on 6.18.0 with
btrfs-raid1+luks:
Opening filesystem to check...
Checking filesystem on /dev/mapper/sdc_crypt
UUID: f8223856-32cc-4dcf-8cee-9312e032c005
[1/8] checking log skipped (none written)
[1/7] checking root items (0:00:59 elapsed, 4875792 items checked)
[2/7] checking extents (0:28:03 elapsed, 4583919 items checked)
[3/7] checking free space tree (0:01:01 elapsed, 8253 items checked)
[4/7] checking fs roots (0:20:30 elapsed, 10978 items checked)
mirror 2 bytenr 870744010752 csum 0xdb1b27f0ca1a0139f7c65a0c0698a9a3f9e6ca6d624da7f70eecb3fc0f14ffc7 expected csum 0x2bce1cca32d98c3f83087f09980770a101b0560b1ddde7919fbbcd58a75f7d6b
mirror 1 bytenr 2004063948800 csum 0xe3f0a16cc8f03705a89f81178d4617c2847d660b7171abe29b65b5b394a9aace expected csum 0xc85b7f37fb620e1a68754692fd7ca43846ca316de6485fc8a4b447bfeab78d78
mirror 2 bytenr 3575828525056 csum 0xb9d9ee193d29b59b2015efed6151029c340a051c0338ec7ebca200363d304be8 expected csum 0xd645b7e5add1aa540a3440b78b7d31daa9545c925d32d2650d6bc61b7fdf4813
mirror 1 bytenr 3714124914688 csum 0xcb2ff575e84a8e965b94bc8faf9e76d8f645742ee9cd503609efd78ac22623e4 expected csum 0x966b1d021450ffb6c47759161533e185f06a14a50c30ff881097a43b7ad6d6cc
mirror 2 bytenr 4211891310592 csum 0xd1c11dabfa4bf3acea463479ab444bbc4c66dc9ba3257f09f4e1815bb46afac2 expected csum 0x17fff4d14269c69d84d267466c577ced3787fd9a9a445e36642067c47f129601
mirror 2 bytenr 4328552914944 csum 0x02f75c04f1d921ce34f5b6b9bf40c3b0056971fc89989dad227fc45723938472 expected csum 0xdd6416d001ac47f16e68a24d1438244152355a0774142d4885e5a031c6938d93
mirror 2 bytenr 4681011163136 csum 0x44c0b9d90fb258659e7377e93a96039afcadb501559a0cd831bf8c36f8fa1b2b expected csum 0x36c59223538807fc604537be5d686900031866626f3a1dc788755e92a74869cb
mirror 1 bytenr 4808263344128 csum 0xfd6278ce98b1f15c8aefea981e5ba7a521fa1a08d0f642185abf72e215288618 expected csum 0x1108b8b604c5b21f7d7d80d32a1fd9c0c0e753cad8fb97967dfa3525105bf808
mirror 1 bytenr 4993017057280 csum 0x033440e421102ec0c7b3057eae89dd80f300aecba70d3f1fcf5fe81c2cd6faba expected csum 0xb0e94e343b7291df9aae42a079bd0bba307a1c2ab81315361a49b0d8b6d53f49
mirror 2 bytenr 5037246173184 csum 0x00b807ff8d0a31a79bb947e774c077916b0bd162dbf24fe43e4fca179e364214 expected csum 0x984635996e4c3fed6c701519e9f654b1b0adb06f3921522f6b687bbccd730271
mirror 1 bytenr 5316786614272 csum 0x2805b36b130667ffaf187f1cc6bdab0802e5eb26332f3bae572202c9c34585dd expected csum 0xd7a2bab5bfddacddb610c6044504474c88962ed22d837a881faba8e4e60bee40
mirror 2 bytenr 7293991006208 csum 0x68f917b93233bb6c7e49775c0c0deed66c47fe0027f3d4287a3b2c736fb25a1b expected csum 0x3662cf0b4a35cd0a0b71a475f35a92a6fefdcf21b7ee59a97b261bb6fbda1c8a
[5/7] checking csums against data (33:30:05 elapsed, 6082759 items checked)
ERROR: errors found in csum tree
[6/7] checking root refs (0:00:00 elapsed, 3 items checked)
[8/8] checking quota groups skipped (not enabled on this FS)
found 8848080683008 bytes used, error(s) found
total csum bytes: 68538889856
total tree bytes: 75102781440
total fs tree bytes: 180338688
total extent tree bytes: 340852736
btree space waste bytes: 5344101189
file data blocks allocated: 8776199127040
referenced 8772977901568
The corruptions looked similar to the first time, couldn't get any new
clues out of them. Unfortunately it was on LUKS again because I'd given
up on reproducing this, I'll try without LUKS going forward.
I realized the common factor betwen the original repro and this one was
that I was additionally running an sftp copy of the same files over the
network while the files were being copied between the two local volumes.
mkfs.btrfs -m raid1 -d raid1 --csum blake2 /dev/sda /dev/sdb
mount /dev/sda -o compress=zstd:1 /mnt
rsync -Pav /data/ /mnt
...and then, concurrently from another machine:
sftp -ar nas:/data .
Can anybody else reproduce this corruption with that combo?
Otherwise, I'll keep working on narrowing this down: the tests take ages
to run but require very little actual human time from me, so I'm happy
to keep trying. Any other suggestions are welcome!
Thanks,
Calvin
^ permalink raw reply
* Re: [PATCH v4 06/11] md: support to align bio to limits
From: Li Nan @ 2026-01-12 11:40 UTC (permalink / raw)
To: Yu Kuai, linux-raid
In-Reply-To: <c1b71e5b-4a94-6b35-c0a6-f92bd1fa9dc4@huaweicloud.com>
在 2026/1/12 19:24, Li Nan 写道:
>
>
> 在 2026/1/12 12:28, Yu Kuai 写道:
>> For personalities that report optimal IO size, it indicates that users
>> can get the best IO bandwidth if they issue IO with this size. However
>> there is also an implicit condition that IO should also be aligned to the
>> optimal IO size.
>>
>> Currently, bio will only be split by limits, if bio offset is not aligned
>> to limits, then all split bio will not be aligned. This patch add a new
>> feature to align bio to limits first, and following patches will support
>> this for each personality if necessary.
>>
>> Link:
>> https://lore.kernel.org/linux-raid/20260103154543.832844-7-yukuai@fnnas.com
>> Signed-off-by: Yu Kuai <yukuai@fnnas.com>
>> Reviewed-by: Li Nan <linan122@huawei.com>
>> ---
>> drivers/md/md.c | 54 +++++++++++++++++++++++++++++++++++++++++++++++++
>> drivers/md/md.h | 2 ++
>> 2 files changed, 56 insertions(+)
>>
>> diff --git a/drivers/md/md.c b/drivers/md/md.c
>> index 21b0bc3088d2..731ec800f5cb 100644
>> --- a/drivers/md/md.c
>> +++ b/drivers/md/md.c
>> @@ -428,6 +428,56 @@ bool md_handle_request(struct mddev *mddev, struct
>> bio *bio)
>> }
>> EXPORT_SYMBOL(md_handle_request);
>> +static struct bio *__md_bio_align_to_limits(struct mddev *mddev,
>> + struct bio *bio)
>> +{
>> + unsigned int max_sectors = mddev->gendisk->queue->limits.max_sectors;
>> + sector_t start = bio->bi_iter.bi_sector;
>> + sector_t end = start + bio_sectors(bio);
>> + sector_t align_start;
>> + sector_t align_end;
>> + u32 rem;
>> +
>> + /* calculate align_start = roundup(start, max_sectors) */
>
> Can we use roundup_u64() here?
>
>> + align_start = start;
>> + rem = sector_div(align_start, max_sectors);
>> + /* already aligned */
>> + if (!rem)
>> + return bio;
>> +
>> + align_start = start + max_sectors - rem;
>> +
>> + /* calculate align_end = rounddown(end, max_sectors) */
>
> Use div64_u64_rem() here seems better.
div64_u64_rem is same as sector_div. Please ignore it.
>
>> + align_end = end;
>> + rem = sector_div(align_end, max_sectors);
>> + align_end = end - rem;
>> +
>> + /* bio is too small to split */
>> + if (align_end <= align_start)
>> + return bio;
>> +
>> + return bio_submit_split_bioset(bio, align_start - start,
>> + &mddev->gendisk->bio_split);
>> +}
>> +
--
Thanks,
Nan
^ permalink raw reply
* Re: [PATCH v4 06/11] md: support to align bio to limits
From: Li Nan @ 2026-01-12 11:24 UTC (permalink / raw)
To: Yu Kuai, linux-raid
In-Reply-To: <20260112042857.2334264-7-yukuai@fnnas.com>
在 2026/1/12 12:28, Yu Kuai 写道:
> For personalities that report optimal IO size, it indicates that users
> can get the best IO bandwidth if they issue IO with this size. However
> there is also an implicit condition that IO should also be aligned to the
> optimal IO size.
>
> Currently, bio will only be split by limits, if bio offset is not aligned
> to limits, then all split bio will not be aligned. This patch add a new
> feature to align bio to limits first, and following patches will support
> this for each personality if necessary.
>
> Link: https://lore.kernel.org/linux-raid/20260103154543.832844-7-yukuai@fnnas.com
> Signed-off-by: Yu Kuai <yukuai@fnnas.com>
> Reviewed-by: Li Nan <linan122@huawei.com>
> ---
> drivers/md/md.c | 54 +++++++++++++++++++++++++++++++++++++++++++++++++
> drivers/md/md.h | 2 ++
> 2 files changed, 56 insertions(+)
>
> diff --git a/drivers/md/md.c b/drivers/md/md.c
> index 21b0bc3088d2..731ec800f5cb 100644
> --- a/drivers/md/md.c
> +++ b/drivers/md/md.c
> @@ -428,6 +428,56 @@ bool md_handle_request(struct mddev *mddev, struct bio *bio)
> }
> EXPORT_SYMBOL(md_handle_request);
>
> +static struct bio *__md_bio_align_to_limits(struct mddev *mddev,
> + struct bio *bio)
> +{
> + unsigned int max_sectors = mddev->gendisk->queue->limits.max_sectors;
> + sector_t start = bio->bi_iter.bi_sector;
> + sector_t end = start + bio_sectors(bio);
> + sector_t align_start;
> + sector_t align_end;
> + u32 rem;
> +
> + /* calculate align_start = roundup(start, max_sectors) */
Can we use roundup_u64() here?
> + align_start = start;
> + rem = sector_div(align_start, max_sectors);
> + /* already aligned */
> + if (!rem)
> + return bio;
> +
> + align_start = start + max_sectors - rem;
> +
> + /* calculate align_end = rounddown(end, max_sectors) */
Use div64_u64_rem() here seems better.
> + align_end = end;
> + rem = sector_div(align_end, max_sectors);
> + align_end = end - rem;
> +
> + /* bio is too small to split */
> + if (align_end <= align_start)
> + return bio;
> +
> + return bio_submit_split_bioset(bio, align_start - start,
> + &mddev->gendisk->bio_split);
> +}
> +
--
Thanks,
Nan
^ permalink raw reply
* Re: [PATCH v4 11/11] md: fix abnormal io_opt from member disks
From: Li Nan @ 2026-01-12 7:28 UTC (permalink / raw)
To: Yu Kuai, linux-raid
In-Reply-To: <20260112042857.2334264-12-yukuai@fnnas.com>
在 2026/1/12 12:28, Yu Kuai 写道:
> It's reported that mtp3sas can report abnormal io_opt, for consequence,
> md array will end up with abnormal io_opt as well, due to the
> lcm_not_zero() from blk_stack_limits().
>
> Some personalities will configure optimal IO size, and it's indicate that
> users can get the best IO bandwidth if they issue IO with this size, and
> we don't want io_opt to be covered by member disks with abnormal io_opt.
>
> Fix this problem by adding a new mddev flags MD_STACK_IO_OPT to indicate
> that io_opt configured by personalities is preferred over member disks
> or not.
>
> Reported-by: Filippo Giunchedi <filippo@debian.org>
> Closes: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=1121006
> Reported-by: Coly Li <colyli@fnnas.com>
> Closes: https://lore.kernel.org/all/20250817152645.7115-1-colyli@kernel.org/
> Signed-off-by: Yu Kuai <yukuai@fnnas.com>
> ---
> drivers/md/md.c | 28 +++++++++++++++++++++++++++-
> drivers/md/md.h | 3 ++-
> drivers/md/raid1.c | 2 +-
> drivers/md/raid10.c | 4 ++--
> 4 files changed, 32 insertions(+), 5 deletions(-)
>
> diff --git a/drivers/md/md.c b/drivers/md/md.c
> index 731ec800f5cb..6c0fb09c26dc 100644
> --- a/drivers/md/md.c
> +++ b/drivers/md/md.c
> @@ -6200,18 +6200,33 @@ static const struct kobj_type md_ktype = {
>
> int mdp_major = 0;
>
> +static bool rdev_is_mddev(struct md_rdev *rdev)
> +{
> + return rdev->bdev->bd_disk->fops == &md_fops;
> +}
> +
> /* stack the limit for all rdevs into lim */
> int mddev_stack_rdev_limits(struct mddev *mddev, struct queue_limits *lim,
> unsigned int flags)
> {
> struct md_rdev *rdev;
> + bool io_opt_configured = lim->io_opt;
>
> rdev_for_each(rdev, mddev) {
> + unsigned int io_opt = lim->io_opt;
> +
> queue_limits_stack_bdev(lim, rdev->bdev, rdev->data_offset,
> mddev->gendisk->disk_name);
> if ((flags & MDDEV_STACK_INTEGRITY) &&
> !queue_limits_stack_integrity_bdev(lim, rdev->bdev))
> return -EINVAL;
> +
> + /*
> + * If member disk is not mdraid array, keep the io_opt
> + * from personality and ignore io_opt from member disk.
> + */
> + if (!rdev_is_mddev(rdev) && io_opt_configured)
> + lim->io_opt = io_opt;
> }
>
> /*
> @@ -6230,9 +6245,11 @@ int mddev_stack_rdev_limits(struct mddev *mddev, struct queue_limits *lim,
> EXPORT_SYMBOL_GPL(mddev_stack_rdev_limits);
>
> /* apply the extra stacking limits from a new rdev into mddev */
> -int mddev_stack_new_rdev(struct mddev *mddev, struct md_rdev *rdev)
> +int mddev_stack_new_rdev(struct mddev *mddev, struct md_rdev *rdev,
> + bool io_opt_configured)
> {
> struct queue_limits lim;
> + unsigned int io_opt;
>
> if (mddev_is_dm(mddev))
> return 0;
> @@ -6245,6 +6262,8 @@ int mddev_stack_new_rdev(struct mddev *mddev, struct md_rdev *rdev)
> }
>
> lim = queue_limits_start_update(mddev->gendisk->queue);
> + io_opt = lim.io_opt;
> +
> queue_limits_stack_bdev(&lim, rdev->bdev, rdev->data_offset,
> mddev->gendisk->disk_name);
>
> @@ -6255,6 +6274,13 @@ int mddev_stack_new_rdev(struct mddev *mddev, struct md_rdev *rdev)
> return -ENXIO;
> }
>
> + /*
> + * If member disk is not mdraid array, keep the io_opt from
> + * personality and ignore io_opt from member disk.
> + */
> + if (!rdev_is_mddev(rdev) && io_opt_configured)
> + lim.io_opt = io_opt;
> +
> return queue_limits_commit_update(mddev->gendisk->queue, &lim);
> }
> EXPORT_SYMBOL_GPL(mddev_stack_new_rdev);
> diff --git a/drivers/md/md.h b/drivers/md/md.h
> index ddf989f2a139..80c527b3777d 100644
> --- a/drivers/md/md.h
> +++ b/drivers/md/md.h
> @@ -1041,7 +1041,8 @@ int do_md_run(struct mddev *mddev);
> #define MDDEV_STACK_INTEGRITY (1u << 0)
> int mddev_stack_rdev_limits(struct mddev *mddev, struct queue_limits *lim,
> unsigned int flags);
> -int mddev_stack_new_rdev(struct mddev *mddev, struct md_rdev *rdev);
> +int mddev_stack_new_rdev(struct mddev *mddev, struct md_rdev *rdev,
> + bool io_opt_configured);
> void mddev_update_io_opt(struct mddev *mddev, unsigned int nr_stripes);
>
> extern const struct block_device_operations md_fops;
> diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
> index 1a957dba2640..f3f3086f27fa 100644
> --- a/drivers/md/raid1.c
> +++ b/drivers/md/raid1.c
> @@ -1944,7 +1944,7 @@ static int raid1_add_disk(struct mddev *mddev, struct md_rdev *rdev)
> for (mirror = first; mirror <= last; mirror++) {
> p = conf->mirrors + mirror;
> if (!p->rdev) {
> - err = mddev_stack_new_rdev(mddev, rdev);
> + err = mddev_stack_new_rdev(mddev, rdev, false);
> if (err)
> return err;
>
> diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
> index 2c6b65b83724..a6edc91e7a9a 100644
> --- a/drivers/md/raid10.c
> +++ b/drivers/md/raid10.c
> @@ -2139,7 +2139,7 @@ static int raid10_add_disk(struct mddev *mddev, struct md_rdev *rdev)
> continue;
> }
>
> - err = mddev_stack_new_rdev(mddev, rdev);
> + err = mddev_stack_new_rdev(mddev, rdev, true);
> if (err)
> return err;
> p->head_position = 0;
> @@ -2157,7 +2157,7 @@ static int raid10_add_disk(struct mddev *mddev, struct md_rdev *rdev)
> clear_bit(In_sync, &rdev->flags);
> set_bit(Replacement, &rdev->flags);
> rdev->raid_disk = repl_slot;
> - err = mddev_stack_new_rdev(mddev, rdev);
> + err = mddev_stack_new_rdev(mddev, rdev, true);
> if (err)
> return err;
> conf->fullsync = 1;
LGTM
Reviewed-by: Li Nan <linan122@huawei.com>
--
Thanks,
Nan
^ permalink raw reply
* [PATCH v4 11/11] md: fix abnormal io_opt from member disks
From: Yu Kuai @ 2026-01-12 4:28 UTC (permalink / raw)
To: linux-raid, linan122; +Cc: yukuai
In-Reply-To: <20260112042857.2334264-1-yukuai@fnnas.com>
It's reported that mtp3sas can report abnormal io_opt, for consequence,
md array will end up with abnormal io_opt as well, due to the
lcm_not_zero() from blk_stack_limits().
Some personalities will configure optimal IO size, and it's indicate that
users can get the best IO bandwidth if they issue IO with this size, and
we don't want io_opt to be covered by member disks with abnormal io_opt.
Fix this problem by adding a new mddev flags MD_STACK_IO_OPT to indicate
that io_opt configured by personalities is preferred over member disks
or not.
Reported-by: Filippo Giunchedi <filippo@debian.org>
Closes: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=1121006
Reported-by: Coly Li <colyli@fnnas.com>
Closes: https://lore.kernel.org/all/20250817152645.7115-1-colyli@kernel.org/
Signed-off-by: Yu Kuai <yukuai@fnnas.com>
---
drivers/md/md.c | 28 +++++++++++++++++++++++++++-
drivers/md/md.h | 3 ++-
drivers/md/raid1.c | 2 +-
drivers/md/raid10.c | 4 ++--
4 files changed, 32 insertions(+), 5 deletions(-)
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 731ec800f5cb..6c0fb09c26dc 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -6200,18 +6200,33 @@ static const struct kobj_type md_ktype = {
int mdp_major = 0;
+static bool rdev_is_mddev(struct md_rdev *rdev)
+{
+ return rdev->bdev->bd_disk->fops == &md_fops;
+}
+
/* stack the limit for all rdevs into lim */
int mddev_stack_rdev_limits(struct mddev *mddev, struct queue_limits *lim,
unsigned int flags)
{
struct md_rdev *rdev;
+ bool io_opt_configured = lim->io_opt;
rdev_for_each(rdev, mddev) {
+ unsigned int io_opt = lim->io_opt;
+
queue_limits_stack_bdev(lim, rdev->bdev, rdev->data_offset,
mddev->gendisk->disk_name);
if ((flags & MDDEV_STACK_INTEGRITY) &&
!queue_limits_stack_integrity_bdev(lim, rdev->bdev))
return -EINVAL;
+
+ /*
+ * If member disk is not mdraid array, keep the io_opt
+ * from personality and ignore io_opt from member disk.
+ */
+ if (!rdev_is_mddev(rdev) && io_opt_configured)
+ lim->io_opt = io_opt;
}
/*
@@ -6230,9 +6245,11 @@ int mddev_stack_rdev_limits(struct mddev *mddev, struct queue_limits *lim,
EXPORT_SYMBOL_GPL(mddev_stack_rdev_limits);
/* apply the extra stacking limits from a new rdev into mddev */
-int mddev_stack_new_rdev(struct mddev *mddev, struct md_rdev *rdev)
+int mddev_stack_new_rdev(struct mddev *mddev, struct md_rdev *rdev,
+ bool io_opt_configured)
{
struct queue_limits lim;
+ unsigned int io_opt;
if (mddev_is_dm(mddev))
return 0;
@@ -6245,6 +6262,8 @@ int mddev_stack_new_rdev(struct mddev *mddev, struct md_rdev *rdev)
}
lim = queue_limits_start_update(mddev->gendisk->queue);
+ io_opt = lim.io_opt;
+
queue_limits_stack_bdev(&lim, rdev->bdev, rdev->data_offset,
mddev->gendisk->disk_name);
@@ -6255,6 +6274,13 @@ int mddev_stack_new_rdev(struct mddev *mddev, struct md_rdev *rdev)
return -ENXIO;
}
+ /*
+ * If member disk is not mdraid array, keep the io_opt from
+ * personality and ignore io_opt from member disk.
+ */
+ if (!rdev_is_mddev(rdev) && io_opt_configured)
+ lim.io_opt = io_opt;
+
return queue_limits_commit_update(mddev->gendisk->queue, &lim);
}
EXPORT_SYMBOL_GPL(mddev_stack_new_rdev);
diff --git a/drivers/md/md.h b/drivers/md/md.h
index ddf989f2a139..80c527b3777d 100644
--- a/drivers/md/md.h
+++ b/drivers/md/md.h
@@ -1041,7 +1041,8 @@ int do_md_run(struct mddev *mddev);
#define MDDEV_STACK_INTEGRITY (1u << 0)
int mddev_stack_rdev_limits(struct mddev *mddev, struct queue_limits *lim,
unsigned int flags);
-int mddev_stack_new_rdev(struct mddev *mddev, struct md_rdev *rdev);
+int mddev_stack_new_rdev(struct mddev *mddev, struct md_rdev *rdev,
+ bool io_opt_configured);
void mddev_update_io_opt(struct mddev *mddev, unsigned int nr_stripes);
extern const struct block_device_operations md_fops;
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 1a957dba2640..f3f3086f27fa 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -1944,7 +1944,7 @@ static int raid1_add_disk(struct mddev *mddev, struct md_rdev *rdev)
for (mirror = first; mirror <= last; mirror++) {
p = conf->mirrors + mirror;
if (!p->rdev) {
- err = mddev_stack_new_rdev(mddev, rdev);
+ err = mddev_stack_new_rdev(mddev, rdev, false);
if (err)
return err;
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 2c6b65b83724..a6edc91e7a9a 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -2139,7 +2139,7 @@ static int raid10_add_disk(struct mddev *mddev, struct md_rdev *rdev)
continue;
}
- err = mddev_stack_new_rdev(mddev, rdev);
+ err = mddev_stack_new_rdev(mddev, rdev, true);
if (err)
return err;
p->head_position = 0;
@@ -2157,7 +2157,7 @@ static int raid10_add_disk(struct mddev *mddev, struct md_rdev *rdev)
clear_bit(In_sync, &rdev->flags);
set_bit(Replacement, &rdev->flags);
rdev->raid_disk = repl_slot;
- err = mddev_stack_new_rdev(mddev, rdev);
+ err = mddev_stack_new_rdev(mddev, rdev, true);
if (err)
return err;
conf->fullsync = 1;
--
2.51.0
^ permalink raw reply related
* [PATCH v4 10/11] md/raid0: align bio to io_opt
From: Yu Kuai @ 2026-01-12 4:28 UTC (permalink / raw)
To: linux-raid, linan122; +Cc: yukuai
In-Reply-To: <20260112042857.2334264-1-yukuai@fnnas.com>
The impact is not so significant for raid0 compared to raid5, however
it's still more appropriate to issue IOs evenly to underlying disks.
Signed-off-by: Yu Kuai <yukuai@fnnas.com>
Reviewed-by: Li Nan <linan122@huawei.com>
---
drivers/md/raid0.c | 5 +++--
1 file changed, 3 insertions(+), 2 deletions(-)
diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index f3814a69cd13..0ae44e3bfff2 100644
--- a/drivers/md/raid0.c
+++ b/drivers/md/raid0.c
@@ -29,8 +29,7 @@ module_param(default_layout, int, 0644);
(1L << MD_HAS_PPL) | \
(1L << MD_HAS_MULTIPLE_PPLS) | \
(1L << MD_FAILLAST_DEV) | \
- (1L << MD_SERIALIZE_POLICY) | \
- (1L << MD_BIO_ALIGN))
+ (1L << MD_SERIALIZE_POLICY))
/*
* inform the user of the raid configuration
@@ -398,6 +397,8 @@ static int raid0_set_limits(struct mddev *mddev)
err = mddev_stack_rdev_limits(mddev, &lim, MDDEV_STACK_INTEGRITY);
if (err)
return err;
+
+ md_config_align_limits(mddev, &lim);
return queue_limits_set(mddev->gendisk->queue, &lim);
}
--
2.51.0
^ permalink raw reply related
* [PATCH v4 09/11] md/raid10: align bio to io_opt
From: Yu Kuai @ 2026-01-12 4:28 UTC (permalink / raw)
To: linux-raid, linan122; +Cc: yukuai
In-Reply-To: <20260112042857.2334264-1-yukuai@fnnas.com>
The impact is not so significant for raid10 compared to raid5, however
it's still more appropriate to issue IOs evenly to underlying disks.
Signed-off-by: Yu Kuai <yukuai@fnnas.com>
Reviewed-by: Li Nan <linan122@huawei.com>
---
drivers/md/raid10.c | 2 ++
1 file changed, 2 insertions(+)
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 09328e032f14..2c6b65b83724 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -4008,6 +4008,8 @@ static int raid10_set_queue_limits(struct mddev *mddev)
err = mddev_stack_rdev_limits(mddev, &lim, MDDEV_STACK_INTEGRITY);
if (err)
return err;
+
+ md_config_align_limits(mddev, &lim);
return queue_limits_set(mddev->gendisk->queue, &lim);
}
--
2.51.0
^ permalink raw reply related
* [PATCH v4 08/11] md/raid5: align bio to io_opt
From: Yu Kuai @ 2026-01-12 4:28 UTC (permalink / raw)
To: linux-raid, linan122; +Cc: yukuai
In-Reply-To: <20260112042857.2334264-1-yukuai@fnnas.com>
raid5 internal implementaion indicates that if write bio is aligned to
io_opt, then full stripe write will be used, which will be best for
bandwidth because there is no need to read extra data to build new
xor data.
Simple test in my VM, 32 disks raid5 with 64kb chunksize:
dd if=/dev/zero of=/dev/md0 bs=100M oflag=direct
Before this patch: 782 MB/s
With this patch: 1.1 GB/s
BTW, there are still other bottleneck related to stripe handler, and
require further optimization.
Signed-off-by: Yu Kuai <yukuai@fnnas.com>
Reviewed-by: Li Nan <linan122@huawei.com>
---
drivers/md/raid5.c | 6 ++----
1 file changed, 2 insertions(+), 4 deletions(-)
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 30a7069cbd0c..0160cbed7389 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -59,8 +59,7 @@
#define UNSUPPORTED_MDDEV_FLAGS \
((1L << MD_FAILFAST_SUPPORTED) | \
(1L << MD_FAILLAST_DEV) | \
- (1L << MD_SERIALIZE_POLICY) | \
- (1L << MD_BIO_ALIGN))
+ (1L << MD_SERIALIZE_POLICY))
#define cpu_to_group(cpu) cpu_to_node(cpu)
@@ -7817,8 +7816,7 @@ static int raid5_set_limits(struct mddev *mddev)
* Limit the max sectors based on this.
*/
lim.max_hw_sectors = RAID5_MAX_REQ_STRIPES << RAID5_STRIPE_SHIFT(conf);
- if ((lim.max_hw_sectors << 9) < lim.io_opt)
- lim.max_hw_sectors = lim.io_opt >> 9;
+ md_config_align_limits(mddev, &lim);
/* No restrictions on the number of segments in the request */
lim.max_segments = USHRT_MAX;
--
2.51.0
^ permalink raw reply related
* [PATCH v4 07/11] md: add a helper md_config_align_limits()
From: Yu Kuai @ 2026-01-12 4:28 UTC (permalink / raw)
To: linux-raid, linan122; +Cc: yukuai
In-Reply-To: <20260112042857.2334264-1-yukuai@fnnas.com>
This helper will be used by personalities that want to align bio to
io_opt to get best IO bandwidth.
Also add the new flag to UNSUPPORTED_MDDEV_FLAGS for now, following
patches will enable this for personalities.
Signed-off-by: Yu Kuai <yukuai@fnnas.com>
Reviewed-by: Li Nan <linan122@huawei.com>
---
drivers/md/md.h | 11 +++++++++++
drivers/md/raid0.c | 3 ++-
drivers/md/raid1.c | 3 ++-
drivers/md/raid5.c | 3 ++-
4 files changed, 17 insertions(+), 3 deletions(-)
diff --git a/drivers/md/md.h b/drivers/md/md.h
index e7aba83b708b..ddf989f2a139 100644
--- a/drivers/md/md.h
+++ b/drivers/md/md.h
@@ -1091,6 +1091,17 @@ static inline bool rdev_blocked(struct md_rdev *rdev)
return false;
}
+static inline void md_config_align_limits(struct mddev *mddev,
+ struct queue_limits *lim)
+{
+ if ((lim->max_hw_sectors << 9) < lim->io_opt)
+ lim->max_hw_sectors = lim->io_opt >> 9;
+ else
+ lim->max_hw_sectors = rounddown(lim->max_hw_sectors,
+ lim->io_opt >> 9);
+ set_bit(MD_BIO_ALIGN, &mddev->flags);
+}
+
#define mddev_add_trace_msg(mddev, fmt, args...) \
do { \
if (!mddev_is_dm(mddev)) \
diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index d83b2b1c0049..f3814a69cd13 100644
--- a/drivers/md/raid0.c
+++ b/drivers/md/raid0.c
@@ -29,7 +29,8 @@ module_param(default_layout, int, 0644);
(1L << MD_HAS_PPL) | \
(1L << MD_HAS_MULTIPLE_PPLS) | \
(1L << MD_FAILLAST_DEV) | \
- (1L << MD_SERIALIZE_POLICY))
+ (1L << MD_SERIALIZE_POLICY) | \
+ (1L << MD_BIO_ALIGN))
/*
* inform the user of the raid configuration
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index f4c7004888af..1a957dba2640 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -42,7 +42,8 @@
((1L << MD_HAS_JOURNAL) | \
(1L << MD_JOURNAL_CLEAN) | \
(1L << MD_HAS_PPL) | \
- (1L << MD_HAS_MULTIPLE_PPLS))
+ (1L << MD_HAS_MULTIPLE_PPLS) | \
+ (1L << MD_BIO_ALIGN))
static void allow_barrier(struct r1conf *conf, sector_t sector_nr);
static void lower_barrier(struct r1conf *conf, sector_t sector_nr);
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index af48ad2bc723..30a7069cbd0c 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -59,7 +59,8 @@
#define UNSUPPORTED_MDDEV_FLAGS \
((1L << MD_FAILFAST_SUPPORTED) | \
(1L << MD_FAILLAST_DEV) | \
- (1L << MD_SERIALIZE_POLICY))
+ (1L << MD_SERIALIZE_POLICY) | \
+ (1L << MD_BIO_ALIGN))
#define cpu_to_group(cpu) cpu_to_node(cpu)
--
2.51.0
^ permalink raw reply related
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox