[PATCH for-next v3 4/7] mm/slab: fix a deadlock in memcg_alloc_abort_single()
From: Harry Yoo (Meta)
Date: Sun Nov 15 2026 - 10:10:37 EST
When kmalloc_nolock() successfully grabs a slab object but memcg aborts
the allocation, the object is freed via __slab_free(). Calling
__slab_free() in unknown context is not allowed and can lead to a
deadlock.
Free the object via defer_free() when spinning is not allowed.
While at it, try freeing the object to the percpu sheaves first in both
contexts, as kmem_cache_free_bulk() already does for bulk allocations.
This also avoids queueing an irq_work for every failed charge when
spinning is not allowed.
Reported-by: Sashiko <sashiko-bot@xxxxxxxxxx>
Closes: https://sashiko.dev/#/patchset/20260610-slab_alloc_flags-v2-0-7190909db118%40kernel.org?part=9
Fixes: af92793e52c3 ("slab: Introduce kmalloc_nolock() and kfree_nolock().")
Signed-off-by: Harry Yoo (Meta) <harry@xxxxxxxxxx>
---
mm/slab.h | 8 ++++++++
mm/slub.c | 22 +++++++++++++++++-----
2 files changed, 25 insertions(+), 5 deletions(-)
diff --git a/mm/slab.h b/mm/slab.h
index 15b0d98ae1d4..fb80a72ad952 100644
--- a/mm/slab.h
+++ b/mm/slab.h
@@ -37,6 +37,14 @@ static inline unsigned int to_alloc_flags(unsigned int free_flags)
return SLAB_ALLOC_DEFAULT;
}
+static inline unsigned int to_free_flags(unsigned int alloc_flags)
+{
+ if (alloc_flags & SLAB_ALLOC_NOLOCK)
+ return SLAB_FREE_NOLOCK;
+ else
+ return SLAB_FREE_DEFAULT;
+}
+
static inline bool alloc_flags_allow_spinning(const unsigned int alloc_flags)
{
return !(alloc_flags & SLAB_ALLOC_NOLOCK);
diff --git a/mm/slub.c b/mm/slub.c
index 7c0adc104988..8252c0b681cc 100644
--- a/mm/slub.c
+++ b/mm/slub.c
@@ -2531,7 +2531,8 @@ static inline void slab_obj_ext_has_codetag_init(void)
#ifdef CONFIG_MEMCG
-static void memcg_alloc_abort_single(struct kmem_cache *s, void *object);
+static void memcg_alloc_abort_single(struct kmem_cache *s, void *object,
+ unsigned int alloc_flags);
static __fastpath_inline
bool memcg_slab_post_alloc_hook(struct kmem_cache *s, gfp_t flags,
@@ -2549,7 +2550,7 @@ bool memcg_slab_post_alloc_hook(struct kmem_cache *s, gfp_t flags,
return true;
if (likely(size == 1)) {
- memcg_alloc_abort_single(s, *p);
+ memcg_alloc_abort_single(s, *p, ac->alloc_flags);
*p = NULL;
} else {
kmem_cache_free_bulk(s, size, p);
@@ -6647,18 +6648,29 @@ void slab_free(struct kmem_cache *s, struct slab *slab, void *object,
#ifdef CONFIG_MEMCG
/* Do not inline the rare memcg charging failed path into the allocation path */
static noinline
-void memcg_alloc_abort_single(struct kmem_cache *s, void *object)
+void memcg_alloc_abort_single(struct kmem_cache *s, void *object,
+ unsigned int alloc_flags)
{
struct slab *slab = virt_to_slab(object);
- unsigned int free_flags = SLAB_FREE_DEFAULT;
+ bool allow_spin = alloc_flags_allow_spinning(alloc_flags);
+ unsigned int free_flags = to_free_flags(alloc_flags);
if (slab_want_init_on_free(s))
free_flags |= SLAB_FREE_INIT;
alloc_tagging_slab_free_hook(s, slab, &object, 1);
- if (likely(slab_free_hook(s, object, free_flags)))
+ if (unlikely(!slab_free_hook(s, object, free_flags)))
+ return;
+
+ if (likely(can_free_to_pcs(slab)) &&
+ likely(free_to_pcs(s, object, allow_spin)))
+ return;
+
+ if (likely(allow_spin))
__slab_free(s, slab, object, object, 1, _RET_IP_);
+ else
+ defer_free(s, object);
}
#endif
--
2.54.0