mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
* [PATCH] mm/slub: don't let kmemleak report rcu sheaves
@ 2026-11-13 15:18 Nguyen Ngoc Thang
  2026-11-16 10:54 ` Vlastimil Babka (SUSE)
  2026-11-18 16:10 ` Catalin Marinas
  0 siblings, 2 replies; 5+ messages in thread
From: Nguyen Ngoc Thang @ 2026-11-13 15:18 UTC (permalink / raw)
  To: Vlastimil Babka, Harry Yoo, Andrew Morton
  Cc: Catalin Marinas, Hao Li, Christoph Lameter, David Rientjes,
	Roman Gushchin, Suren Baghdasaryan, linux-mm, linux-kernel,
	syzbot+527fed49e5b988882c9a

kmemleak reports full rcu sheaves as leaked:

  unreferenced object 0xffff88810005f600 (size 512):
    hex dump (first 32 bytes):
      e0 79 f0 2b 81 88 ff ff 20 00 b4 81 ff ff ff ff
      00 12 04 00 81 88 ff ff 3c 00 00 00 00 00 00 00
    backtrace:
      __alloc_empty_sheaf mm/slub.c:2854 [inline]
      alloc_empty_sheaf mm/slub.c:2874 [inline]
      __pcs_replace_empty_main+0x260/0x2e0 mm/slub.c:4806

The second word is rcu_free_sheaf and the size equals the capacity: the
sheaf was handed to call_rcu() by __kfree_rcu_sheaf() and is waiting for
a grace period. At that point the only reference to it is the ->next
pointer of the previous callback in the rcu callback list.

That previous callback may live in memory kmemleak never scans, e.g. the
rcu_head of a struct slab queued by rcu_free_slab() for a
SLAB_TYPESAFE_BY_RCU cache. Slab pages are frozen (page_count() == 0),
so kmemleak skips their struct page. The chain from rcu_data is cut and
the sheaf, typically allocated long ago and recycled, looks unreferenced.
Since the sheaf is then not scanned either, the objects it is about to
free can be reported as well.

Sheaves are allocator metadata and are always owned by a pcs, a barn or
an rcu callback. Mark them with kmemleak_not_leak(): they are never
reported but still scanned, so objects queued in them stay referenced.
Allocations that can't spin are not tracked by kmemleak, so skip them,
as alloc_slab_obj_exts() does.

Fixes: ec66e0d59952 ("slab: add sheaf support for batching kfree_rcu() operations")
Reported-by: syzbot+527fed49e5b988882c9a@syzkaller.appspotmail.com
Closes: https://syzkaller.appspot.com/bug?extid=527fed49e5b988882c9a
Signed-off-by: Nguyen Ngoc Thang <ngocthang2710.1999@gmail.com>
---
Reproduced in QEMU (syzbot config, 2 vCPUs, numa=fake=2) by stalling a
grace period with a preempted reader on CPU0 while CPU1 interleaves
rcu_free_slab() (filp slabs) and rcu_free_sheaf() (maple nodes freed by
kfree_rcu()) callbacks, then running two kmemleak scans:

  before: 16-18 sheaves reported per run, rcu_head.func == rcu_free_sheaf,
          plus maple nodes held by them
  after:  no sheaf or maple node reports, no new warnings

 mm/slub.c | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/mm/slub.c b/mm/slub.c
index cd671b934719..e01416ae0b4a 100644
--- a/mm/slub.c
+++ b/mm/slub.c
@@ -2856,6 +2856,14 @@ static struct slab_sheaf *__alloc_empty_sheaf(struct kmem_cache *s, gfp_t gfp,
 	if (unlikely(!sheaf))
 		return NULL;
 
+	/*
+	 * A queued rcu sheaf may only be referenced by an earlier rcu callback
+	 * in memory kmemleak doesn't scan (e.g. struct slab). Never report
+	 * sheaves, but keep scanning the objects they hold.
+	 */
+	if (alloc_flags_allow_spinning(alloc_flags))
+		kmemleak_not_leak(sheaf);
+
 	sheaf->cache = s;
 
 	stat(s, SHEAF_ALLOC);
-- 
2.43.0


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

* Re: [PATCH] mm/slub: don't let kmemleak report rcu sheaves
  2026-11-13 15:18 [PATCH] mm/slub: don't let kmemleak report rcu sheaves Nguyen Ngoc Thang
@ 2026-11-16 10:54 ` Vlastimil Babka (SUSE)
  2026-11-17 23:05   ` Catalin Marinas
  2026-11-18 16:10 ` Catalin Marinas
  1 sibling, 1 reply; 5+ messages in thread
From: Vlastimil Babka (SUSE) @ 2026-11-16 10:54 UTC (permalink / raw)
  To: Nguyen Ngoc Thang, Harry Yoo, Andrew Morton
  Cc: Catalin Marinas, Hao Li, Christoph Lameter, David Rientjes,
	Roman Gushchin, Suren Baghdasaryan, linux-mm, linux-kernel,
	syzbot+527fed49e5b988882c9a, Breno Leitao

+CC Breno

On 11/13/26 16:18, Nguyen Ngoc Thang wrote:
> kmemleak reports full rcu sheaves as leaked:
> 
>   unreferenced object 0xffff88810005f600 (size 512):
>     hex dump (first 32 bytes):
>       e0 79 f0 2b 81 88 ff ff 20 00 b4 81 ff ff ff ff
>       00 12 04 00 81 88 ff ff 3c 00 00 00 00 00 00 00
>     backtrace:
>       __alloc_empty_sheaf mm/slub.c:2854 [inline]
>       alloc_empty_sheaf mm/slub.c:2874 [inline]
>       __pcs_replace_empty_main+0x260/0x2e0 mm/slub.c:4806
> 
> The second word is rcu_free_sheaf and the size equals the capacity: the
> sheaf was handed to call_rcu() by __kfree_rcu_sheaf() and is waiting for
> a grace period. At that point the only reference to it is the ->next
> pointer of the previous callback in the rcu callback list.
> 
> That previous callback may live in memory kmemleak never scans, e.g. the
> rcu_head of a struct slab queued by rcu_free_slab() for a
> SLAB_TYPESAFE_BY_RCU cache. Slab pages are frozen (page_count() == 0),
> so kmemleak skips their struct page. The chain from rcu_data is cut and
> the sheaf, typically allocated long ago and recycled, looks unreferenced.
> Since the sheaf is then not scanned either, the objects it is about to
> free can be reported as well.

I don't get this part. The previous object can't be that much gone, RCU
still needs to get to this sheaf at some point, so there has to be a live
pointer somewhere?

> Sheaves are allocator metadata and are always owned by a pcs, a barn or
> an rcu callback. Mark them with kmemleak_not_leak(): they are never
> reported but still scanned, so objects queued in them stay referenced.
> Allocations that can't spin are not tracked by kmemleak, so skip them,
> as alloc_slab_obj_exts() does.
> 
> Fixes: ec66e0d59952 ("slab: add sheaf support for batching kfree_rcu() operations")
> Reported-by: syzbot+527fed49e5b988882c9a@syzkaller.appspotmail.com
> Closes: https://syzkaller.appspot.com/bug?extid=527fed49e5b988882c9a
> Signed-off-by: Nguyen Ngoc Thang <ngocthang2710.1999@gmail.com>

I wonder if we should rather do this at the moment the sheaf is handed over
to rcu.
Or if it's a generic problem that should rather be solved by kmemleak having
visibility to the rcu queues.

> ---
> Reproduced in QEMU (syzbot config, 2 vCPUs, numa=fake=2) by stalling a
> grace period with a preempted reader on CPU0 while CPU1 interleaves
> rcu_free_slab() (filp slabs) and rcu_free_sheaf() (maple nodes freed by
> kfree_rcu()) callbacks, then running two kmemleak scans:
> 
>   before: 16-18 sheaves reported per run, rcu_head.func == rcu_free_sheaf,
>           plus maple nodes held by them
>   after:  no sheaf or maple node reports, no new warnings
> 
>  mm/slub.c | 8 ++++++++
>  1 file changed, 8 insertions(+)
> 
> diff --git a/mm/slub.c b/mm/slub.c
> index cd671b934719..e01416ae0b4a 100644
> --- a/mm/slub.c
> +++ b/mm/slub.c
> @@ -2856,6 +2856,14 @@ static struct slab_sheaf *__alloc_empty_sheaf(struct kmem_cache *s, gfp_t gfp,
>  	if (unlikely(!sheaf))
>  		return NULL;
>  
> +	/*
> +	 * A queued rcu sheaf may only be referenced by an earlier rcu callback
> +	 * in memory kmemleak doesn't scan (e.g. struct slab). Never report
> +	 * sheaves, but keep scanning the objects they hold.
> +	 */
> +	if (alloc_flags_allow_spinning(alloc_flags))
> +		kmemleak_not_leak(sheaf);
> +
>  	sheaf->cache = s;
>  
>  	stat(s, SHEAF_ALLOC);


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

* Re: [PATCH] mm/slub: don't let kmemleak report rcu sheaves
  2026-11-16 10:54 ` Vlastimil Babka (SUSE)
@ 2026-11-17 23:05   ` Catalin Marinas
  2026-11-18 16:06     ` Catalin Marinas
  0 siblings, 1 reply; 5+ messages in thread
From: Catalin Marinas @ 2026-11-17 23:05 UTC (permalink / raw)
  To: Vlastimil Babka (SUSE)
  Cc: Nguyen Ngoc Thang, Harry Yoo, Andrew Morton, Hao Li,
	Christoph Lameter, David Rientjes, Roman Gushchin,
	Suren Baghdasaryan, linux-mm, linux-kernel,
	syzbot+527fed49e5b988882c9a, Breno Leitao

On Mon, Nov 16, 2026 at 11:54:37AM +0100, Vlastimil Babka (SUSE) wrote:
> +CC Breno
> 
> On 11/13/26 16:18, Nguyen Ngoc Thang wrote:
> > kmemleak reports full rcu sheaves as leaked:
> > 
> >   unreferenced object 0xffff88810005f600 (size 512):
> >     hex dump (first 32 bytes):
> >       e0 79 f0 2b 81 88 ff ff 20 00 b4 81 ff ff ff ff
> >       00 12 04 00 81 88 ff ff 3c 00 00 00 00 00 00 00
> >     backtrace:
> >       __alloc_empty_sheaf mm/slub.c:2854 [inline]
> >       alloc_empty_sheaf mm/slub.c:2874 [inline]
> >       __pcs_replace_empty_main+0x260/0x2e0 mm/slub.c:4806
> > 
> > The second word is rcu_free_sheaf and the size equals the capacity: the
> > sheaf was handed to call_rcu() by __kfree_rcu_sheaf() and is waiting for
> > a grace period. At that point the only reference to it is the ->next
> > pointer of the previous callback in the rcu callback list.
> > 
> > That previous callback may live in memory kmemleak never scans, e.g. the
> > rcu_head of a struct slab queued by rcu_free_slab() for a
> > SLAB_TYPESAFE_BY_RCU cache. Slab pages are frozen (page_count() == 0),
> > so kmemleak skips their struct page. The chain from rcu_data is cut and
> > the sheaf, typically allocated long ago and recycled, looks unreferenced.
> > Since the sheaf is then not scanned either, the objects it is about to
> > free can be reported as well.
> 
> I don't get this part. The previous object can't be that much gone, RCU
> still needs to get to this sheaf at some point, so there has to be a live
> pointer somewhere?

After some back and forth with claude, I think there are a couple of
places where kmemleak fails to track. Since commit 9aec2fb0fd5e ("slab:
allocate frozen pages"), kmemleak no longer scans the slab structures in
scan_zone_pages(). We could do something like below:

diff --git a/mm/kmemleak.c b/mm/kmemleak.c
index 20c0eb41c873..47446af5fc9f 100644
--- a/mm/kmemleak.c
+++ b/mm/kmemleak.c
@@ -1875,9 +1875,13 @@ static int scan_zone_pages(struct zone *zone)
 		if (!(pfn & 63))
 			cond_resched_tasks_rcu_qs();
 
-		/* only scan in-use pages belonging to this zone */
+		/*
+		 * Only scan in-use pages belonging to this zone. Slab pages
+		 * are frozen (zero refcount) but struct slab holds pointers
+		 * such as the rcu_head of a slab pending rcu_free_slab().
+		 */
 		if (page && (page_zone(page) != zone ||
-			     page_count(page) == 0))
+			     (page_count(page) == 0 && !PageSlab(page))))
 			page = NULL;
 
 		if (page && first && page == last + 1 &&


I don't think this is specific to sheaves, SLAB_TYPESAFE_BY_RCU may have
a similar problem, though I don't remember to have seen such reports
yet. It should be covered by the above.

However, this only fixes the links through struct slab. The rcu list can
also go through a sheaf allocated with kmalloc_nolock(), which kmemleak
doesn't track. Any callback queued after it is missed (together with the
objects queued in that sheaf that may come from ordinary kfree_rcu()).
When kmemleak is enabled, could we simply avoid allocating sheaves with
kmalloc_nolock(), i.e.:

diff --git a/mm/slub.c b/mm/slub.c
index 45e077c7526c..13b8e57d6dae 100644
--- a/mm/slub.c
+++ b/mm/slub.c
@@ -6278,6 +6278,14 @@ bool __kfree_rcu_sheaf(struct kmem_cache *s, void *obj, unsigned int free_flags)

 		local_unlock(&s->cpu_sheaves->lock);

+		/*
+		 * A sheaf allocated with kmalloc_nolock() is not tracked by
+		 * kmemleak, so neither its objects nor the rcu callback queued
+		 * after it would be scanned. Fall back to defer_kfree_rcu().
+		 */
+		if (IS_ENABLED(CONFIG_DEBUG_KMEMLEAK) && !allow_spin)
+			goto fail;
+
 		/* Don't wake up kswapd, it will cause deadlock under pi_lock */
 		empty = alloc_empty_sheaf(s, __GFP_NOWARN, alloc_flags);
 

Not tested and it's possible I misunderstood how all this works. But if
it works, I don't think the kmemleak_not_leak() annotation is needed.

-- 
Catalin

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

* Re: [PATCH] mm/slub: don't let kmemleak report rcu sheaves
  2026-11-17 23:05   ` Catalin Marinas
@ 2026-11-18 16:06     ` Catalin Marinas
  0 siblings, 0 replies; 5+ messages in thread
From: Catalin Marinas @ 2026-11-18 16:06 UTC (permalink / raw)
  To: Vlastimil Babka (SUSE)
  Cc: Nguyen Ngoc Thang, Harry Yoo, Andrew Morton, Hao Li,
	Christoph Lameter, David Rientjes, Roman Gushchin,
	Suren Baghdasaryan, linux-mm, linux-kernel,
	syzbot+527fed49e5b988882c9a, Breno Leitao

On Tue, Nov 17, 2026 at 11:05:28PM +0000, Catalin Marinas wrote:
> After some back and forth with claude, I think there are a couple of
> places where kmemleak fails to track. Since commit 9aec2fb0fd5e ("slab:
> allocate frozen pages"), kmemleak no longer scans the slab structures in
> scan_zone_pages(). We could do something like below:
> 
> diff --git a/mm/kmemleak.c b/mm/kmemleak.c
> index 20c0eb41c873..47446af5fc9f 100644
> --- a/mm/kmemleak.c
> +++ b/mm/kmemleak.c
> @@ -1875,9 +1875,13 @@ static int scan_zone_pages(struct zone *zone)
>  		if (!(pfn & 63))
>  			cond_resched_tasks_rcu_qs();
>  
> -		/* only scan in-use pages belonging to this zone */
> +		/*
> +		 * Only scan in-use pages belonging to this zone. Slab pages
> +		 * are frozen (zero refcount) but struct slab holds pointers
> +		 * such as the rcu_head of a slab pending rcu_free_slab().
> +		 */
>  		if (page && (page_zone(page) != zone ||
> -			     page_count(page) == 0))
> +			     (page_count(page) == 0 && !PageSlab(page))))
>  			page = NULL;
>  
>  		if (page && first && page == last + 1 &&
> 
> 
> I don't think this is specific to sheaves, SLAB_TYPESAFE_BY_RCU may have
> a similar problem, though I don't remember to have seen such reports
> yet. It should be covered by the above.

This still leaves a hole. Scanning the slab descriptor recovers the link
through slab->rcu_head.next, but the preceding callback can also be
free_object_rcu() whose rcu_head is embedded in a kmemleak metadata
object allocated from a SLAB_NOLEAKTRACE cache. This would break the
chain.

So I think we should keep the original kmemleak_not_leak() patch at
allocation.

> However, this only fixes the links through struct slab. The rcu list can
> also go through a sheaf allocated with kmalloc_nolock(), which kmemleak
> doesn't track. Any callback queued after it is missed (together with the
> objects queued in that sheaf that may come from ordinary kfree_rcu()).
> When kmemleak is enabled, could we simply avoid allocating sheaves with
> kmalloc_nolock(), i.e.:
> 
> diff --git a/mm/slub.c b/mm/slub.c
> index 45e077c7526c..13b8e57d6dae 100644
> --- a/mm/slub.c
> +++ b/mm/slub.c
> @@ -6278,6 +6278,14 @@ bool __kfree_rcu_sheaf(struct kmem_cache *s, void *obj, unsigned int free_flags)
> 
>  		local_unlock(&s->cpu_sheaves->lock);
> 
> +		/*
> +		 * A sheaf allocated with kmalloc_nolock() is not tracked by
> +		 * kmemleak, so neither its objects nor the rcu callback queued
> +		 * after it would be scanned. Fall back to defer_kfree_rcu().
> +		 */
> +		if (IS_ENABLED(CONFIG_DEBUG_KMEMLEAK) && !allow_spin)
> +			goto fail;
> +
>  		/* Don't wake up kswapd, it will cause deadlock under pi_lock */
>  		empty = alloc_empty_sheaf(s, __GFP_NOWARN, alloc_flags);
>  

For the objects queued in a sheaf, rather than the !allow_spin fallback
above, it's simpler to move the kmemleak_ignore() call in
kvfree_call_rcu() before kfree_rcu_sheaf(), so they are treated the same
as on the non-sheaf path. kfree_rcu_nolock() currently only has a kunit
user, freeing kmalloc_nolock() objects that kmemleak doesn't track
anyway.

So this second hunk isn't needed either.

To Vlastimil's earlier point, kmemleak could follow these rcu chains
instead of relying on kmemleak_not_leak(). However, with chain breaks at
any _nolock or SLAB_NOLEAKTRACE object (including kmemleak's own
metadata) and walking the rcu callback lists directly means digging
into rcu internals. The annotation is easier to maintain.

(got lost in all the slub code, it was much simpler 17 years ago when we
merged kmemleak ;))

-- 
Catalin

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

* Re: [PATCH] mm/slub: don't let kmemleak report rcu sheaves
  2026-11-13 15:18 [PATCH] mm/slub: don't let kmemleak report rcu sheaves Nguyen Ngoc Thang
  2026-11-16 10:54 ` Vlastimil Babka (SUSE)
@ 2026-11-18 16:10 ` Catalin Marinas
  1 sibling, 0 replies; 5+ messages in thread
From: Catalin Marinas @ 2026-11-18 16:10 UTC (permalink / raw)
  To: Nguyen Ngoc Thang
  Cc: Vlastimil Babka, Harry Yoo, Andrew Morton, Hao Li,
	Christoph Lameter, David Rientjes, Roman Gushchin,
	Suren Baghdasaryan, linux-mm, linux-kernel,
	syzbot+527fed49e5b988882c9a

On Fri, Nov 13, 2026 at 10:18:37PM +0700, Nguyen Ngoc Thang wrote:
> kmemleak reports full rcu sheaves as leaked:
> 
>   unreferenced object 0xffff88810005f600 (size 512):
>     hex dump (first 32 bytes):
>       e0 79 f0 2b 81 88 ff ff 20 00 b4 81 ff ff ff ff
>       00 12 04 00 81 88 ff ff 3c 00 00 00 00 00 00 00
>     backtrace:
>       __alloc_empty_sheaf mm/slub.c:2854 [inline]
>       alloc_empty_sheaf mm/slub.c:2874 [inline]
>       __pcs_replace_empty_main+0x260/0x2e0 mm/slub.c:4806
> 
> The second word is rcu_free_sheaf and the size equals the capacity: the
> sheaf was handed to call_rcu() by __kfree_rcu_sheaf() and is waiting for
> a grace period. At that point the only reference to it is the ->next
> pointer of the previous callback in the rcu callback list.
> 
> That previous callback may live in memory kmemleak never scans, e.g. the
> rcu_head of a struct slab queued by rcu_free_slab() for a
> SLAB_TYPESAFE_BY_RCU cache. Slab pages are frozen (page_count() == 0),
> so kmemleak skips their struct page. The chain from rcu_data is cut and
> the sheaf, typically allocated long ago and recycled, looks unreferenced.
> Since the sheaf is then not scanned either, the objects it is about to
> free can be reported as well.
> 
> Sheaves are allocator metadata and are always owned by a pcs, a barn or
> an rcu callback. Mark them with kmemleak_not_leak(): they are never
> reported but still scanned, so objects queued in them stay referenced.
> Allocations that can't spin are not tracked by kmemleak, so skip them,
> as alloc_slab_obj_exts() does.
> 
> Fixes: ec66e0d59952 ("slab: add sheaf support for batching kfree_rcu() operations")
> Reported-by: syzbot+527fed49e5b988882c9a@syzkaller.appspotmail.com
> Closes: https://syzkaller.appspot.com/bug?extid=527fed49e5b988882c9a
> Signed-off-by: Nguyen Ngoc Thang <ngocthang2710.1999@gmail.com>
> ---
> Reproduced in QEMU (syzbot config, 2 vCPUs, numa=fake=2) by stalling a
> grace period with a preempted reader on CPU0 while CPU1 interleaves
> rcu_free_slab() (filp slabs) and rcu_free_sheaf() (maple nodes freed by
> kfree_rcu()) callbacks, then running two kmemleak scans:
> 
>   before: 16-18 sheaves reported per run, rcu_head.func == rcu_free_sheaf,
>           plus maple nodes held by them
>   after:  no sheaf or maple node reports, no new warnings
> 
>  mm/slub.c | 8 ++++++++
>  1 file changed, 8 insertions(+)
> 
> diff --git a/mm/slub.c b/mm/slub.c
> index cd671b934719..e01416ae0b4a 100644
> --- a/mm/slub.c
> +++ b/mm/slub.c
> @@ -2856,6 +2856,14 @@ static struct slab_sheaf *__alloc_empty_sheaf(struct kmem_cache *s, gfp_t gfp,
>  	if (unlikely(!sheaf))
>  		return NULL;
>  
> +	/*
> +	 * A queued rcu sheaf may only be referenced by an earlier rcu callback
> +	 * in memory kmemleak doesn't scan (e.g. struct slab). Never report
> +	 * sheaves, but keep scanning the objects they hold.
> +	 */
> +	if (alloc_flags_allow_spinning(alloc_flags))
> +		kmemleak_not_leak(sheaf);
> +
>  	sheaf->cache = s;
>  
>  	stat(s, SHEAF_ALLOC);

Reviewed-by: Catalin Marinas <catalin.marinas@arm.com>

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

end of thread, other threads:[~2026-11-18 16:10 UTC | newest]

Thread overview: 5+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2026-11-13 15:18 [PATCH] mm/slub: don't let kmemleak report rcu sheaves Nguyen Ngoc Thang
2026-11-16 10:54 ` Vlastimil Babka (SUSE)
2026-11-17 23:05   ` Catalin Marinas
2026-11-18 16:06     ` Catalin Marinas
2026-11-18 16:10 ` Catalin Marinas

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox

all inboxes | Powered by JetHome®