[PATCH v3 00/15] common kmalloc v3

[Hyeonggon Yoo <42.hyeyoo@gmail.com>]

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
https://github.com/hygoni/linux/tree/slab-common-v3r0

Any feedbacks/reviews will be appreciated.

v2->v3:
	- 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
	  tracepoint.
	
	- 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
    allocator
  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
    using
  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(-)

-- 
2.34.1