mm/mempolicy: fix memory leaks in weighted_interleave_auto_store()
Subsystems (2)
PATCH v2 1/1 mm/mempolicy: fix memory leaks in weighted_interleave_auto_store()
From: Jackie Liu <[email protected]>
weighted_interleave_auto_store() fetches old_wi_state inside the if (!input) block only. This causes two memory leaks:
1. When a user writes "false" and the current mode is already manual, the function returns early without freeing the freshly allocated new_wi_state.
2. When a user writes "true", old_wi_state stays NULL because the fetch is skipped entirely. The old state is then overwritten by rcu_assign_pointer() but never freed, since the cleanup path is gated on old_wi_state being non-NULL. A user can trigger this repeatedly by writing "1" in a loop.
Fix both leaks by moving the old_wi_state fetch before the input check, making it unconditional. This also allows a unified early return for both "true" and "false" when the requested mode matches the current mode.
---
Changes in v2:
- Move old_wi_state fetch unconditionally before the input check, instead of just adding kfree() to the early return path
- Also fix an additional memory leak when writing "true" where the previous wi_state was never freed (Sashiko)
mm/mempolicy.c | 23 ++++++++++++----------- 1 file changed, 12 insertions(+), 11 deletions(-)
mm/mempolicy.c +12 -11
@@ -3706,18 +3706,19 @@ static ssize_t weighted_interleave_auto_store(struct kobject *kobj, new_wi_state->iw_table[i] =1 ;mutex_lock (&wi_state_lock); -if (!input) { - old_wi_state =rcu_dereference_protected (wi_state, -lockdep_is_held (&wi_state_lock)); -if (!old_wi_state) - goto update_wi_state; -if (input == old_wi_state->mode_auto) { -mutex_unlock (&wi_state_lock); -return count; - } + old_wi_state =rcu_dereference_protected (wi_state, +lockdep_is_held (&wi_state_lock)); -memcpy (new_wi_state->iw_table, old_wi_state->iw_table, - nr_node_ids *sizeof (u8)); +if (old_wi_state && input == old_wi_state->mode_auto) { +mutex_unlock (&wi_state_lock); +kfree (new_wi_state); +return count; + } + +if (!input) { +if (old_wi_state) +memcpy (new_wi_state->iw_table, old_wi_state->iw_table, + nr_node_ids *sizeof (u8)); goto update_wi_state; }
Signature · 1 line
2.51.1
Andrew Morton
maintainerQuoted 20 lines · On Wed, 1 Apr 2026 08:57:02 +0800 Jackie Liu <[email protected]> wrote:
From: Jackie Liu <[email protected]>
weighted_interleave_auto_store()fetchesold_wi_stateinside the if (!input) block only. This causes two memory leaks:1. When a user writes "false" and the current mode is already manual, the function returns early without freeing the freshly allocated
new_wi_state.2. When a user writes "true",
old_wi_statestays NULL because the fetch is skipped entirely. The old state is then overwritten byrcu_assign_pointer()but never freed, since the cleanup path is gated onold_wi_statebeing non-NULL. A user can trigger this repeatedly by writing "1" in a loop.Fix both leaks by moving the
old_wi_statefetch before the input check, making it unconditional. This also allows a unified early return for both "true" and "false" when the requested mode matches the current mode.
Quoted 4 lines
Cc [email protected] # v6.16+Fixes e341f9c3c841 ("mm/mempolicy: Weighted Interleave Auto-tuning")Signed-off-by Jackie Liu <[email protected]>
Thanks.
Quoted 5 lines
Changes in v2:
- Moveold_wi_statefetch unconditionally before the input check, instead of just addingkfree()to the early return path
- Also fix an additional memory leak when writing "true" where the previouswi_statewas never freed (Sashiko)
Yes, this has changed a lot since v1, so your removal of the three Reviewed-by:s is appropriate.
mm/mempolicy.c | 23 ++++++++++++----------- 1 file changed, 12 insertions(+), 11 deletions(-)
mm/mempolicy.c renamed from mm/mempolicy.c~mm-mempolicy-fix-memory-leaks-in-weighted_interleave_auto_store +12 -11
@@ -3700,18 +3700,19 @@ static ssize_t weighted_interleave_auto_ new_wi_state->iw_table[i] =1 ;mutex_lock (&wi_state_lock); -if (!input) { - old_wi_state =rcu_dereference_protected (wi_state, -lockdep_is_held (&wi_state_lock)); -if (!old_wi_state) - goto update_wi_state; -if (input == old_wi_state->mode_auto) { -mutex_unlock (&wi_state_lock); -return count; - } + old_wi_state =rcu_dereference_protected (wi_state, +lockdep_is_held (&wi_state_lock)); + +if (old_wi_state && input == old_wi_state->mode_auto) { +mutex_unlock (&wi_state_lock); +kfree (new_wi_state); +return count; + } -memcpy (new_wi_state->iw_table, old_wi_state->iw_table, - nr_node_ids *sizeof (u8)); +if (!input) { +if (old_wi_state) +memcpy (new_wi_state->iw_table, old_wi_state->iw_table, + nr_node_ids *sizeof (u8)); goto update_wi_state; }
_
Quoted 15 lines · On Wed, 1 Apr 2026 08:57:02 +0800 Jackie Liu <[email protected]> wrote:
From: Jackie Liu <[email protected]>
weighted_interleave_auto_store()fetchesold_wi_stateinside the if (!input) block only. This causes two memory leaks:1. When a user writes "false" and the current mode is already manual, the function returns early without freeing the freshly allocated
new_wi_state.2. When a user writes "true",
old_wi_statestays NULL because the fetch is skipped entirely. The old state is then overwritten byrcu_assign_pointer()but never freed, since the cleanup path is gated onold_wi_statebeing non-NULL. A user can trigger this repeatedly by writing "1" in a loop.
Quoted 4 lines
Fix both leaks by moving the
old_wi_statefetch before the input check, making it unconditional. This also allows a unified early return for both "true" and "false" when the requested mode matches the current mode.
Hi Jackie,
Thank you for the quick turnaround on the patch, and also thank you for fixing the second bug as well. This looks good to me! So much cleaner than before as well : -)
Quoted 51 lines
Cc [email protected] # v6.16+Fixes e341f9c3c841 ("mm/mempolicy: Weighted Interleave Auto-tuning")Signed-off-by Jackie Liu <[email protected]>---
Changes in v2:
- Moveold_wi_statefetch unconditionally before the input check, instead of just addingkfree()to the early return path
- Also fix an additional memory leak when writing "true" where the previouswi_statewas never freed (Sashiko)mm/mempolicy.c | 23 ++++++++++++----------- 1 file changed, 12 insertions(+), 11 deletions(-)mm/mempolicy.c +12
-11@@ -3706,18 +3706,19 @@ static ssize_t weighted_interleave_auto_store(struct kobject *kobj, new_wi_state->iw_table[i] =1 ;mutex_lock (&wi_state_lock); -if (!input) { - old_wi_state =rcu_dereference_protected (wi_state, -lockdep_is_held (&wi_state_lock)); -if (!old_wi_state) - goto update_wi_state; -if (input == old_wi_state->mode_auto) { -mutex_unlock (&wi_state_lock); -return count; - } + old_wi_state =rcu_dereference_protected (wi_state, +lockdep_is_held (&wi_state_lock)); -memcpy (new_wi_state->iw_table, old_wi_state->iw_table, - nr_node_ids *sizeof (u8)); +if (old_wi_state && input == old_wi_state->mode_auto) { +mutex_unlock (&wi_state_lock); +kfree (new_wi_state); +return count; + } + +if (!input) { +if (old_wi_state) +memcpy (new_wi_state->iw_table, old_wi_state->iw_table, + nr_node_ids *sizeof (u8)); goto update_wi_state; }Signature · 1 line
2.51.1
Quoted 51 lines · Jackie Liu
From: Jackie Liu<[email protected]>
weighted_interleave_auto_store()fetchesold_wi_stateinside the if (!input) block only. This causes two memory leaks:1. When a user writes "false" and the current mode is already manual, the function returns early without freeing the freshly allocated
new_wi_state.2. When a user writes "true",
old_wi_statestays NULL because the fetch is skipped entirely. The old state is then overwritten byrcu_assign_pointer()but never freed, since the cleanup path is gated onold_wi_statebeing non-NULL. A user can trigger this repeatedly by writing "1" in a loop.Fix both leaks by moving the
old_wi_statefetch before the input
check, making it unconditional. This also allows a unified early
return for both "true" and "false" when the requested mode matches the current mode. Cc: [email protected] # v6.16+ Link: https://sashiko.dev/#/patchset/[email protected] Fixes:e341f9c3c841("mm/mempolicy: Weighted Interleave Auto-tuning")Signed-off-by Jackie Liu<[email protected]>---
Changes in v2:
- Moveold_wi_statefetch unconditionally before the input check, instead of just addingkfree()to the early return path
- Also fix an additional memory leak when writing "true" where the previouswi_statewas never freed (Sashiko)mm/mempolicy.c | 23 ++++++++++++----------- 1 file changed, 12 insertions(+), 11 deletions(-)mm/mempolicy.c +2
-11@@ -3706,18 +3706,19 @@ static ssize_t weighted_interleave_auto_store(struct kobject *kobj, new_wi_state->iw_table[i] =1 ;mutex_lock (&wi_state_lock); -if (!input) { - old_wi_state =rcu_dereference_protected (wi_state, -lockdep_is_held (&wi_state_lock)); -if (!old_wi_state) - goto update_wi_state; -if (input == old_wi_state->mode_auto) { -mutex_unlock (&wi_state_lock); -return count; - } + old_wi_state =rcu_dereference_protected (wi_state, +lockdep_is_held (&wi_state_lock)); -memcpy (new_wi_state->iw_table, old_wi_state->iw_table, - nr_node_ids *sizeof (u8));
mm/mempolicy.c static ssize_t weighted_interleave_auto_store(struct kobject *kobj, · line 3721
Quoted 10 lines
mm/mempolicy.c +10
-0+if (old_wi_state && input == old_wi_state->mode_auto) { +mutex_unlock (&wi_state_lock); +kfree (new_wi_state); +return count; + } + +if (!input) { +if (old_wi_state) +memcpy (new_wi_state->iw_table, old_wi_state->iw_table, + nr_node_ids *sizeof (u8));
Yes, these are valid issues. This looks good to me.
Reviewed by: Donet Tom <[email protected]>
Quoted 3 lines
mm/mempolicy.c +0
-0goto update_wi_state; }