Re: [PATCH] mm/mempolicy: fix copy_nodes_to_user() for odd inputs
From: Gregory Price (Meta)
Date: Tue Nov 17 2026 - 14:59:44 EST
What about the following:
--- 1/2 mm/mempolicy: convert maxnode to a bit count in copy_nodes_to_user()
Converts maxnode to a bit count on entry to copy_nodes_to_user() and get_nodes(), fixing the compat KASAN stack over-read and stack leak. Fixes e130242dc351, Cc stable.
Subject: [PATCH 1/2] mm/mempolicy: convert maxnode to a bit count in
copy_nodes_to_user()
Whenever maxnode - 1 is a multiple of 32, compat_put_bitmap() reads one
more compat_ulong_t from the kernel nodemask than the caller asked for,
and writes it past the end of the caller's bitmap.
When the kernel nodemask ends there, that read goes past the on-stack
nodemask_t in kernel_get_mempolicy(), and its low 32 bits are copied
to userspace.
With CONFIG_NODES_SHIFT=6, 64 possible nodes and a 32-bit caller
passing maxnode=65:
BUG: KASAN: stack-out-of-bounds in compat_put_bitmap+0x122/0x130
Read of size 8 at addr ffff8880150d7ec0 by task mpoltest/241
compat_put_bitmap+0x122/0x130
copy_nodes_to_user+0x14a/0x250
__ia32_sys_get_mempolicy+0x1b0/0x2b0
Convert maxnode to a bit count once, on entry, and use only that in the
rest of copy_nodes_to_user(), so the compat path gets the same size as
the native one. Do the same in get_nodes().
Fixes: e130242dc351 ("mm: simplify compat numa syscalls")
Cc: stable@xxxxxxxxxxxxxxx
---
mm/mempolicy.c | 36 ++++++++++++++++++++++--------------
1 file changed, 22 insertions(+), 14 deletions(-)
diff --git a/mm/mempolicy.c b/mm/mempolicy.c
index 4da1cb8777f68..390a31a99b4ff 100644
--- a/mm/mempolicy.c
+++ b/mm/mempolicy.c
@@ -1673,15 +1673,22 @@ static int get_bitmap(unsigned long *mask, const unsigned long __user *nmask,
return 0;
}
-/* Copy a node mask from user space. */
+/*
+ * Copy a node mask from user space.
+ *
+ * The nodemask syscalls take maxnode as the size of the user bitmap in bits
+ * plus one. get_nodes() and copy_nodes_to_user() take it as passed and
+ * convert it to the bitmap size, nbits, on entry.
+ */
static int get_nodes(nodemask_t *nodes, const unsigned long __user *nmask,
unsigned long maxnode)
{
- --maxnode;
+ unsigned long nbits = maxnode - 1;
+
nodes_clear(*nodes);
- if (maxnode == 0 || !nmask)
+ if (nbits == 0 || !nmask)
return 0;
- if (maxnode > PAGE_SIZE*BITS_PER_BYTE)
+ if (nbits > PAGE_SIZE*BITS_PER_BYTE)
return -EINVAL;
/*
@@ -1689,31 +1696,32 @@ static int get_nodes(nodemask_t *nodes, const unsigned long __user *nmask,
* if the non supported part is all zero, one word at a time,
* starting at the end.
*/
- while (maxnode > MAX_NUMNODES) {
- unsigned long bits = min_t(unsigned long, maxnode, BITS_PER_LONG);
+ while (nbits > MAX_NUMNODES) {
+ unsigned long bits = min_t(unsigned long, nbits, BITS_PER_LONG);
unsigned long t;
- if (get_bitmap(&t, &nmask[(maxnode - 1) / BITS_PER_LONG], bits))
+ if (get_bitmap(&t, &nmask[(nbits - 1) / BITS_PER_LONG], bits))
return -EFAULT;
- if (maxnode - bits >= MAX_NUMNODES) {
- maxnode -= bits;
+ if (nbits - bits >= MAX_NUMNODES) {
+ nbits -= bits;
} else {
- maxnode = MAX_NUMNODES;
+ nbits = MAX_NUMNODES;
t &= ~((1UL << (MAX_NUMNODES % BITS_PER_LONG)) - 1);
}
if (t)
return -EINVAL;
}
- return get_bitmap(nodes_addr(*nodes), nmask, maxnode);
+ return get_bitmap(nodes_addr(*nodes), nmask, nbits);
}
/* Copy a kernel node mask to user space */
static int copy_nodes_to_user(unsigned long __user *mask, unsigned long maxnode,
nodemask_t *nodes)
{
- unsigned long copy = ALIGN(maxnode-1, 64) / 8;
+ unsigned long nbits = maxnode - 1;
+ unsigned long copy = ALIGN(nbits, 64) / 8;
unsigned int nbytes = BITS_TO_LONGS(nr_node_ids) * sizeof(long);
bool compat = in_compat_syscall();
@@ -1726,12 +1734,12 @@ static int copy_nodes_to_user(unsigned long __user *mask, unsigned long maxnode,
if (clear_user((char __user *)mask + nbytes, copy - nbytes))
return -EFAULT;
copy = nbytes;
- maxnode = nr_node_ids;
+ nbits = nr_node_ids;
}
if (compat)
return compat_put_bitmap((compat_ulong_t __user *)mask,
- nodes_addr(*nodes), maxnode);
+ nodes_addr(*nodes), nbits);
return copy_to_user(mask, nodes_addr(*nodes), copy) ? -EFAULT : 0;
}
--
2.56.1
--- 2/2 mm/mempolicy: size compat get_mempolicy() copies in compat words
Rounds the compat copy size to BITS_PER_COMPAT_LONG, so 32-bit callers
no longer get 4 bytes written past odd-sized masks.
Subject: [PATCH 2/2] mm/mempolicy: size compat get_mempolicy() copies in
compat words
copy_nodes_to_user() rounds the size of the user bitmap up to 64 bits
for compat callers too, whose bitmap is an array of 32-bit
compat_ulong_t.
When the caller's bitmap holds an odd number of compat words and is
larger than the kernel's nodes, the clear_user() of the tail writes
four bytes past its end.
Example: a 32-bit task asking for a 32-bit mask (maxnode=33) on a
2-node system gets 8 bytes written.
Round the compat copy size to BITS_PER_COMPAT_LONG, so it covers exactly
the words the caller passed.
Fixes: e130242dc351 ("mm: simplify compat numa syscalls")
Cc: stable@xxxxxxxxxxxxxxx
---
mm/mempolicy.c | 4 +++-
1 file changed, 3 insertions(+), 1 deletion(-)
diff --git a/mm/mempolicy.c b/mm/mempolicy.c
index 390a31a99b4ff..cddca1db3d9a1 100644
--- a/mm/mempolicy.c
+++ b/mm/mempolicy.c
@@ -1725,8 +1725,10 @@ static int copy_nodes_to_user(unsigned long __user *mask, unsigned long maxnode,
unsigned int nbytes = BITS_TO_LONGS(nr_node_ids) * sizeof(long);
bool compat = in_compat_syscall();
- if (compat)
+ if (compat) {
+ copy = ALIGN(nbits, BITS_PER_COMPAT_LONG) / 8;
nbytes = BITS_TO_COMPAT_LONGS(nr_node_ids) * sizeof(compat_long_t);
+ }
if (copy > nbytes) {
if (copy > PAGE_SIZE)
--
2.56.1