Linux-mm Archive on lore.kernel.org
 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)
  0 siblings, 1 reply; 3+ 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 related	[flat|nested] 3+ 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
  0 siblings, 1 reply; 3+ 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] 3+ 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
  0 siblings, 0 replies; 3+ 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 related	[flat|nested] 3+ messages in thread

end of thread, other threads:[~2026-11-17 23:05 UTC | newest]

Thread overview: 3+ 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

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