All of lore.kernel.org
 help / color / mirror / Atom feed
* [PATCH] md: bound raid_disks by max_disks for v0.90 metadata
@ 2026-11-19  9:01 Yang Luohan
  2026-11-19  9:15 ` sashiko-bot
  0 siblings, 1 reply; 2+ messages in thread
From: Yang Luohan @ 2026-11-19  9:01 UTC (permalink / raw)
  To: song; +Cc: yukuai3, linux-raid, linux-kernel

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>

diff --git a/drivers/md/md.c b/drivers/md/md.c
index d1465bcd8..769ed1f09 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -1610,7 +1610,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..
 	 *
@@ -1643,7 +1643,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);
@@ -1727,7 +1727,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;
@@ -4441,6 +4441,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:
@@ -5029,6 +5031,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;

^ permalink raw reply related	[flat|nested] 2+ messages in thread

* 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

end of thread, other threads:[~2026-11-19  9:15 UTC | newest]

Thread overview: 2+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
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

This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.