[PATCH v3 00/15] common kmalloc v3

From: Hyeonggon Yoo
Date: Tue Jul 12 2022 - 09:40:00 EST

This is v3 of common kmalloc series.

This series generalize most of kmalloc functions and move its
implementation into mm/slab_common.c.

I believe this series give better maintainability of code for SLAB and SLUB.
Please consider applying.

This series is based on slab/for-next and also available at

Any feedbacks/reviews will be appreciated.

- Now this series does not unify tracepoints between kmalloc and
kmem_cache_alloc(). And does not print its name.
Instead, it implements common alloc/free function without

- Dropped UMA version of tracepoints and removed _node suffix
for NUMA version. (Vlastimil Babka)

- Split kmem_alloc event class and defined kmem_cache_alloc and
kmalloc events using TRACE_EVENT() macro. And avoided
dereferencing fields of struct kmem_cache when not using
tracepoints. (Vlastimil Babka)

- Dropped patches cleaning up kmalloc() to avoid increasing size of
kernel image. (Joe Perches)

- Tried to avoid affecting inlined kmalloc calls
and kmem_cache_alloc varients.

- Fixed uninitialized variable bug in SLAB with NUMA.

- Fixed an issue printing useless caller in
kmalloc_node_track_caller() when it calls kmalloc_large_node().

- call WARN_ON() when __ksize() returns zero. (Christoph Lameter)

- Adjusted feedbacks from Vlastimil Babka.
(Coding Style, patch organization, etc.)

Thank you all for feedback :)

===== sequence of patches =====

patch 1-2 make slab_alloc_node() available for non-NUMA
configurations for generalization.

patch 3-5 remove duplicate code in common kmalloc functions.

patch 6-10 move implementation of kmalloc_large{,_node}()
to slab_common.c and make SLAB pass requests larger than
order-1 page to page allocator. (like SLUB)

patch 11-12 generalize most of kmalloc functions.

patch 13 drops kmem_alloc event class and rename
kmem_alloc_node to kmem_alloc. and remove _node suffix
for its events.

patch 14 drop kmem_alloc event class and then define
kmalloc and kmem_cache_alloc events using TRACE_EVENT() macro.
It also avoids dereferencing fields when not using tracepoints.

patch 15-16 are small improvements of __ksize(). They are
not part of generalization but depends on this series.

mm/slab: move NUMA-related code to __do_cache_alloc()
mm/slab: cleanup slab_alloc() and slab_alloc_node()
mm/slab_common: remove CONFIG_NUMA ifdefs for common kmalloc functions
mm/slab_common: cleanup kmalloc_track_caller()
mm/sl[au]b: factor out __do_kmalloc_node()
mm/sl[auo]b: fold kmalloc_order_trace() into kmalloc_large()
mm/slub: move kmalloc_large_node() to slab_common.c
mm/slab_common: kmalloc_node: pass large requests to page allocator
mm/slab_common: cleanup kmalloc_large()
mm/slab: kmalloc: pass requests larger than order-1 page to page
mm/sl[au]b: introduce common alloc/free functions without tracepoint
mm/sl[au]b: generalize kmalloc subsystem
mm/slab_common: unify NUMA and UMA version of tracepoints
mm/slab_common: drop kmem_alloc & avoid dereferencing fields when not
mm/sl[auo]b: move definition of __ksize() to mm/slab.h
mm/sl[au]b: check if large object is valid in __ksize()

include/linux/slab.h | 117 +++++----------
include/trace/events/kmem.h | 68 +++------
mm/slab.c | 290 ++++++++++--------------------------
mm/slab.h | 11 ++
mm/slab_common.c | 176 +++++++++++++++++++---
mm/slob.c | 28 +---
mm/slub.c | 218 +++------------------------
7 files changed, 320 insertions(+), 588 deletions(-)