* Re: [PATCH] md: bound raid_disks by max_disks for v0.90 metadata
2026-11-19 9:01 [PATCH] md: bound raid_disks by max_disks for v0.90 metadata Yang Luohan
@ 2026-11-19 9:15 ` sashiko-bot
0 siblings, 0 replies; 2+ messages in thread
From: sashiko-bot @ 2026-11-19 9:15 UTC (permalink / raw)
To: Yang Luohan; +Cc: linux-raid, yukuai
Thank you for your contribution! Sashiko AI review found 5 potential
issues to consider:
- [High] md: out-of-bounds access to sb->disks[] in super_90_sync()
- [Medium] md: missing raid_disks check and max_disks init in
md_set_array_info()
- [Medium] md: max_disks check bypass and int overflow in
raid_disks_store()
- [Low] md: incomplete max_disks check and stale max_disks in
metadata_store()
- [Low] md: 10-char SHA in Fixes trailer and duplicated subject in
changelog
--
commit 0588d69c6a4d85b9a67f6669d8e19860ad381e67
Author: Yang Luohan <ylh440104@gmail.com>
> md: bound raid_disks by max_disks for v0.90 metadata
>
> md: bound raid_disks by max_disks for v0.90 metadata
>
> commit 1a33a379e6 ("md: reject v0.90 arrays with too many devices")
> bounded sb->raid_disks in super_90_load(), so a crafted superblock can
> no longer describe more devices than a v0.90 superblock is able to hold.
> mddev->raid_disks however is not only loaded from the superblock.
>
> Both the raid_disks sysfs attribute and MD_SET_ARRAY_INFO write it
> directly while the array has no personality, and neither enforces any
> upper bound. super_90_sync() then lays out the in-superblock device
> table using mddev->raid_disks and walks past the end of the 4 KiB
> superblock page.
>
> mddev->max_disks already carries the limit that the selected metadata
> format can represent, and update_raid_disks() already enforces it, but
> it is only initialized when a superblock is read from a member device.
> An array that has just been created through sysfs or
> MD_SET_ARRAY_INFO has max_disks cleared, so the check is skipped.
>
> Set max_disks when v0.90 metadata is selected in metadata_store(), and
> reject values the selected format cannot represent in
> raid_disks_store(). Both orderings are then covered: the limit is
> installed either before the value is written or together with the
> metadata choice. Clamp super_90_sync() as well, so an array which
> already carries a larger value cannot walk past sb->disks[].
>
> v1.x metadata sets max_disks to (4096-256)/2 and is therefore not
> affected by the v0.90 limit.
>
> Fixes: 1a33a379e6 ("md: reject v0.90 arrays with too many devices")
> Signed-off-by: Yang Luohan <ylh440104@gmail.com>
[Severity: Low]
The Fixes: tag uses a 10-character SHA instead of at least 12 characters:
Fixes: 1a33a379e678 ("md: reject v0.90 arrays with too many devices")
The subject line is also duplicated at the top of the commit message body.
[Severity: Medium]
The commit message notes that MD_SET_ARRAY_INFO writes mddev->raid_disks
directly and leaves max_disks cleared, but md_set_array_info() is not
updated in this patch.
When info->raid_disks != 0, md_set_array_info() assigns mddev->raid_disks
= info->raid_disks without checking it against 0 or MD_SB_DISKS. When
info->raid_disks == 0, it sets major_version, minor_version and persistent
while leaving mddev->max_disks == 0, so a subsequent sysfs write to
raid_disks_store() still bypasses the max_disks check.
> diff --git a/drivers/md/md.c b/drivers/md/md.c
> index 47da9edc1c606..788521a55a13c 100644
> --- a/drivers/md/md.c
> +++ b/drivers/md/md.c
> @@ -1630,7 +1630,7 @@ static void super_90_sync(struct mddev *mddev, struct md_rdev *rdev)
> {
> mdp_super_t *sb;
> struct md_rdev *rdev2;
> - int next_spare = mddev->raid_disks;
> + int next_spare = min_t(int, mddev->raid_disks, MD_SB_DISKS);
>
> /* make rdev->sb match mddev data..
> *
> @@ -1663,7 +1663,7 @@ static void super_90_sync(struct mddev *mddev, struct md_rdev *rdev)
> sb->ctime = clamp_t(time64_t, mddev->ctime, 0, U32_MAX);
> sb->level = mddev->level;
> sb->size = mddev->dev_sectors / 2;
> - sb->raid_disks = mddev->raid_disks;
> + sb->raid_disks = min_t(int, mddev->raid_disks, MD_SB_DISKS);
> sb->md_minor = mddev->md_minor;
> sb->not_persistent = 0;
> sb->utime = clamp_t(time64_t, mddev->utime, 0, U32_MAX);
> @@ -1747,7 +1747,7 @@ static void super_90_sync(struct mddev *mddev, struct md_rdev *rdev)
> d->state |= (1<<MD_DISK_FAILFAST);
> }
> /* now set the "removed" and "faulty" bits on any missing devices */
> - for (i=0 ; i < mddev->raid_disks ; i++) {
> + for (i=0 ; i < min_t(int, mddev->raid_disks, MD_SB_DISKS) ; i++) {
> mdp_disk_t *d = &sb->disks[i];
> if (d->state == 0 && d->number == 0) {
> d->number = i;
[Severity: High]
Can super_90_sync() still access sb->disks[] out of bounds in the
rdev_for_each() loop and at sb->this_disk = sb->disks[rdev->desc_nr]?
sb->disks has MD_SB_DISKS (27) entries (indices 0..26), followed by
sb->this_disk at the end of the 4 KiB rdev->sb_page:
drivers/md/md.c:super_90_sync() {
...
rdev_for_each(rdev2, mddev) {
...
if (is_active)
desc_nr = rdev2->raid_disk;
else
desc_nr = next_spare++;
rdev2->desc_nr = desc_nr;
d = &sb->disks[rdev2->desc_nr];
...
sb->this_disk = sb->disks[rdev->desc_nr];
}
When mddev->raid_disks >= MD_SB_DISKS (or when mddev->raid_disks plus the
number of spare or faulty devices in mddev->disks exceeds MD_SB_DISKS),
next_spare++ reaches >= MD_SB_DISKS, and rdev2->raid_disk for active
devices is not bounded against MD_SB_DISKS either. Indexing
sb->disks[rdev2->desc_nr] and sb->disks[rdev->desc_nr] then reads and
writes past sb->disks[] and past the 4 KiB superblock page.
> @@ -4473,6 +4473,8 @@ raid_disks_store(struct mddev *mddev, const char *buf, size_t len)
> mddev->delta_disks = n - olddisks;
> mddev->raid_disks = n;
> mddev->reshape_backwards = (mddev->delta_disks < 0);
> + } else if (mddev->max_disks && n >= mddev->max_disks) {
> + err = -EINVAL;
> } else
> mddev->raid_disks = n;
> out_unlock:
[Severity: Medium]
Can raid_disks_store() bypass the max_disks check or overflow
mddev->raid_disks?
Because the new check is placed after the mddev->reshape_position !=
MaxSector branch, writing to raid_disks while mddev->pers == NULL and
reshape_position != MaxSector assigns mddev->raid_disks = n without
checking mddev->max_disks.
In addition, n is parsed as an unsigned int while mddev->raid_disks is a
signed int. If n > INT_MAX is written while mddev->max_disks == 0,
mddev->raid_disks becomes negative, which then passes the signed
mddev->raid_disks >= MD_SB_DISKS check in metadata_store() and causes
min_t(int, mddev->raid_disks, MD_SB_DISKS) in super_90_sync() to evaluate
to a negative number.
> @@ -5067,6 +5069,13 @@ metadata_store(struct mddev *mddev, const char *buf, size_t len)
> err = -ENOENT;
> if (major >= ARRAY_SIZE(super_types) || super_types[major].name == NULL)
> goto out_unlock;
> + err = -EINVAL;
> + if (major == 0 && mddev->raid_disks >= MD_SB_DISKS)
> + goto out_unlock;
> + if (major == 0)
> + mddev->max_disks = MD_SB_DISKS;
> + else
> + mddev->max_disks = (4096 - 256) / 2;
> mddev->major_version = major;
> mddev->minor_version = minor;
> mddev->persistent = 1;
[Severity: Low]
Should metadata_store() also validate mddev->raid_disks against the new
max_disks when major != 0, and reset mddev->max_disks = 0 in the "none"
and "external:" branches?
Right now, writing raid_disks >= (4096 - 256) / 2 before selecting v1.x
metadata is not rejected here, and switching metadata_version from 0.90 or
1.x to "none" or "external:" leaves the previous max_disks limit set on
the array.
--
Sashiko AI review · https://sashiko.dev/#/patchset/179507886219.2370.1301636898303569514@gmail.com?part=1
^ permalink raw reply [flat|nested] 2+ messages in thread