mm/slab: replace slab_alloc_node() parameters with slab_alloc_context

The function takes all the parameters that exist as fields in
slab_alloc_context, except alloc_flags. Replace them with a single
pointer.

This moves slab_alloc_context initialization to a number of callers,
which is more verbose, but arguably also more clear than a long list of
parameters, and most do not use the 'lru' field.

This will also allow kmalloc_nolock() to call slab_alloc_node() and
reduce the special open-coding it currently has.

Link: https://patch.msgid.link/20260610-slab_alloc_flags-v2-10-7190909db118@kernel.org
Reviewed-by: Hao Li <hao.li@linux.dev>
Reviewed-by: Suren Baghdasaryan <surenb@google.com>
Reviewed-by: Harry Yoo (Oracle) <harry@kernel.org>
Signed-off-by: Vlastimil Babka (SUSE) <vbabka@kernel.org>

diff --git a/mm/slub.c b/mm/slub.c
index 465eb4db577052eddfedf7d2ea6cdec3f77a073a..562495b80d7400e33cdcf79b3e9fa9f77fd03170 100644 (file)
--- a/mm/slub.c
+++ b/mm/slub.c
@@ -4920,30 +4920,23 @@ do_alloc:
  *
  * Otherwise we can simply pick the next object from the lockless free list.
  */
-static __fastpath_inline void *slab_alloc_node(struct kmem_cache *s, struct list_lru *lru,
-               gfp_t gfpflags, int node, unsigned long addr, size_t orig_size)
+static __fastpath_inline void *slab_alloc_node(struct kmem_cache *s,
+               gfp_t gfpflags, int node, const struct slab_alloc_context *ac)
 {
-       const unsigned int alloc_flags = SLAB_ALLOC_DEFAULT;
        void *object;
-       const struct slab_alloc_context ac = {
-               .caller_addr = addr,
-               .orig_size = orig_size,
-               .alloc_flags = alloc_flags,
-               .lru = lru,
-       };
 
        s = slab_pre_alloc_hook(s, gfpflags);
        if (unlikely(!s))
                return NULL;
 
-       object = kfence_alloc(s, orig_size, gfpflags);
+       object = kfence_alloc(s, ac->orig_size, gfpflags);
        if (unlikely(object))
                goto out;
 
-       object = alloc_from_pcs(s, gfpflags, alloc_flags, node);
+       object = alloc_from_pcs(s, gfpflags, ac->alloc_flags, node);
 
        if (unlikely(!object))
-               object = __slab_alloc_node(s, gfpflags, node, &ac);
+               object = __slab_alloc_node(s, gfpflags, node, ac);
 
        maybe_wipe_obj_freeptr(s, object);
 
@@ -4952,15 +4945,21 @@ out:
         * In case this fails due to memcg_slab_post_alloc_hook(),
         * object is set to NULL
         */
-       slab_post_alloc_hook(s, gfpflags, 1, &object, &ac);
+       slab_post_alloc_hook(s, gfpflags, 1, &object, ac);
 
        return object;
 }
 
 void *kmem_cache_alloc_noprof(struct kmem_cache *s, gfp_t gfpflags)
 {
-       void *ret = slab_alloc_node(s, NULL, gfpflags, NUMA_NO_NODE, _RET_IP_,
-                                   s->object_size);
+       void *ret;
+       const struct slab_alloc_context ac = {
+               .caller_addr = _RET_IP_,
+               .orig_size = s->object_size,
+               .alloc_flags = SLAB_ALLOC_DEFAULT,
+       };
+
+       ret = slab_alloc_node(s, gfpflags, NUMA_NO_NODE, &ac);
 
        trace_kmem_cache_alloc(_RET_IP_, ret, s, gfpflags, NUMA_NO_NODE);
 
@@ -4971,8 +4970,15 @@ EXPORT_SYMBOL(kmem_cache_alloc_noprof);
 void *kmem_cache_alloc_lru_noprof(struct kmem_cache *s, struct list_lru *lru,
                           gfp_t gfpflags)
 {
-       void *ret = slab_alloc_node(s, lru, gfpflags, NUMA_NO_NODE, _RET_IP_,
-                                   s->object_size);
+       void *ret;
+       const struct slab_alloc_context ac = {
+               .caller_addr = _RET_IP_,
+               .orig_size = s->object_size,
+               .alloc_flags = SLAB_ALLOC_DEFAULT,
+               .lru = lru,
+       };
+
+       ret = slab_alloc_node(s, gfpflags, NUMA_NO_NODE, &ac);
 
        trace_kmem_cache_alloc(_RET_IP_, ret, s, gfpflags, NUMA_NO_NODE);
 
@@ -5004,7 +5010,14 @@ EXPORT_SYMBOL(kmem_cache_charge);
  */
 void *kmem_cache_alloc_node_noprof(struct kmem_cache *s, gfp_t gfpflags, int node)
 {
-       void *ret = slab_alloc_node(s, NULL, gfpflags, node, _RET_IP_, s->object_size);
+       void *ret;
+       const struct slab_alloc_context ac = {
+               .caller_addr = _RET_IP_,
+               .orig_size = s->object_size,
+               .alloc_flags = SLAB_ALLOC_DEFAULT,
+       };
+
+       ret = slab_alloc_node(s, gfpflags, node, &ac);
 
        trace_kmem_cache_alloc(_RET_IP_, ret, s, gfpflags, node);
 
@@ -5334,6 +5347,11 @@ void *__do_kmalloc_node(size_t size, kmem_buckets *b, gfp_t flags, int node,
 {
        struct kmem_cache *s;
        void *ret;
+       const struct slab_alloc_context ac = {
+               .caller_addr = caller,
+               .orig_size = size,
+               .alloc_flags = SLAB_ALLOC_DEFAULT,
+       };
 
        if (unlikely(size > KMALLOC_MAX_CACHE_SIZE)) {
                ret = __kmalloc_large_node_noprof(size, flags, node);
@@ -5347,7 +5365,7 @@ void *__do_kmalloc_node(size_t size, kmem_buckets *b, gfp_t flags, int node,
 
        s = kmalloc_slab(size, b, flags, token);
 
-       ret = slab_alloc_node(s, NULL, flags, node, caller, size);
+       ret = slab_alloc_node(s, flags, node, &ac);
        ret = kasan_kmalloc(s, ret, size, flags);
        trace_kmalloc(caller, ret, size, s->size, flags, node);
        return ret;
@@ -5465,8 +5483,14 @@ EXPORT_SYMBOL(__kmalloc_node_track_caller_noprof);
 
 void *__kmalloc_cache_noprof(struct kmem_cache *s, gfp_t gfpflags, size_t size)
 {
-       void *ret = slab_alloc_node(s, NULL, gfpflags, NUMA_NO_NODE,
-                                           _RET_IP_, size);
+       void *ret;
+       const struct slab_alloc_context ac = {
+               .caller_addr = _RET_IP_,
+               .orig_size = size,
+               .alloc_flags = SLAB_ALLOC_DEFAULT,
+       };
+
+       ret = slab_alloc_node(s, gfpflags, NUMA_NO_NODE, &ac);
 
        trace_kmalloc(_RET_IP_, ret, size, s->size, gfpflags, NUMA_NO_NODE);
 
@@ -5478,7 +5502,14 @@ EXPORT_SYMBOL(__kmalloc_cache_noprof);
 void *__kmalloc_cache_node_noprof(struct kmem_cache *s, gfp_t gfpflags,
                                  int node, size_t size)
 {
-       void *ret = slab_alloc_node(s, NULL, gfpflags, node, _RET_IP_, size);
+       void *ret;
+       const struct slab_alloc_context ac = {
+               .caller_addr = _RET_IP_,
+               .orig_size = size,
+               .alloc_flags = SLAB_ALLOC_DEFAULT,
+       };
+
+       ret = slab_alloc_node(s, gfpflags, node, &ac);
 
        trace_kmalloc(_RET_IP_, ret, size, s->size, gfpflags, node);