mm: remove all the slab allocators
Subsystems (3)
PATCH 1/1 mm: remove all the slab allocators
As the SLOB removal is on track and the SLAB removal is planned, I have realized - why should we stop there and not remove also SLUB? What's a slab allocator good for in 2023? The RAM sizes are getting larger and the modules cheaper [1]. The object constructor trick was perhaps interesting in 1994, but not with contemporary CPUs. So all the slab allocator does today is just adding an unnecessary layer of complexity over the page allocator.
Thus, with this patch, all three slab allocators are removed, and only a layer that passes everything to the page allocator remains in the slab.h and mm/slab_common.c files. This will allow users to gradually transition away and use the page allocator directly. To summarize the advantages:
- Less code to maintain: over 13k lines are removed by this patch, and more could be removed if I wast^Wspent more time on this, and later as users are transitioned from the legacy layer. This no longer needs a separate subsystem so remove it from MAINTAINERS (I hope I can keep the kernel.org account anyway, though).
- Simplified MEMCG_KMEM accounting: while I was lazy and just marked it BROKEN in this patch, it should be trivial to use the page memcg accounting now that we use the page allocator. The per-object accounting went through several iterations in the past and was always complex and added overhead. Page accounting is much simpler by comparison.
- Simplified KASAN and friends: also was lazy in this patch so they can't be enabled but should be easy to fix up and work just on the page level.
- Simpler debugging: just use debug_pagealloc=on, no need to look up the exact syntax of the absurdly complex slub_debug parameter.
- Speed: didn't measure, but for the page allocator we have pcplists, so it should scale just fine. No need for the crazy SLUB's cmpxchg_double() craziness. Maybe that thing could be now removed too? Yeah I can see just two remaining users.
Any downsides? Let's look at memory usage after virtme boot:
Before (with SLUB):
Slab: 26304 kB
After:
Slab: 295592 kB
Well, that's not so bad, see [1].
[1] https://www.theregister.com/2023/03/29/dram_prices_crash/
--- MAINTAINERS | 15 - include/linux/slab.h | 211 +- include/linux/slab_def.h | 124 - include/linux/slub_def.h | 198 -- init/Kconfig | 2 +- mm/Kconfig | 134 +- mm/Makefile | 10 - mm/slab.c | 4046 ------------------------ mm/slab.h | 426 --- mm/slab_common.c | 876 ++--- mm/slob.c | 757 ----- mm/slub.c | 6506 -------------------------------------- 12 files changed, 228 insertions(+), 13077 deletions(-) delete mode 100644 include/linux/slab_def.h delete mode 100644 include/linux/slub_def.h delete mode 100644 mm/slab.c delete mode 100644 mm/slob.c delete mode 100644 mm/slub.c
MAINTAINERS +0 -15
@@ -19183,21 +19183,6 @@ F: drivers/irqchip/irq-sl28cpld.c F: drivers/pwm/pwm-sl28cpld.c F: drivers/watchdog/sl28cpld_wdt.c -SLAB ALLOCATOR -M: Christoph Lameter <[email protected]> -M: Pekka Enberg <[email protected]> -M: David Rientjes <[email protected]> -M: Joonsoo Kim <[email protected]> -M: Andrew Morton <[email protected]> -M: Vlastimil Babka <[email protected]> -R: Roman Gushchin <[email protected]> -R: Hyeonggon Yoo <[email protected]> -L: [email protected] -S: Maintained -T: git git://git.kernel.org/pub/scm/linux/kernel/git/vbabka/slab.git -F: include/linux/sl?b*.h -F: mm/sl?b* - SLCAN CAN NETWORK DRIVER M: Dario Binacchi <[email protected]> L: [email protected]
include/linux/slab.h +7 -204
257 lines not on this page · raw message
include/linux/slab_def.h deleted +0 -124
124 lines not on this page · raw message
include/linux/slub_def.h deleted +0 -198
198 lines not on this page · raw message
init/Kconfig +1 -1
@@ -973,7 +973,7 @@ config MEMCG config MEMCG_KMEM bool - depends on MEMCG && !SLOB + depends on MEMCG && BROKEN default y config BLK_CGROUP
mm/Kconfig +4 -130
148 lines not on this page · raw message
mm/Makefile +0 -10
@@ -4,16 +4,12 @@ # KASAN_SANITIZE_slab_common.o := n -KASAN_SANITIZE_slab.o := n -KASAN_SANITIZE_slub.o := n KCSAN_SANITIZE_kmemleak.o := n # These produce frequent data race reports: most of them are due to races on # the same word but accesses to different bits of that word. Re-enable KCSAN # for these when we have more consensus on what to do about them. KCSAN_SANITIZE_slab_common.o := n -KCSAN_SANITIZE_slab.o := n -KCSAN_SANITIZE_slub.o := n KCSAN_SANITIZE_page_alloc.o := n # But enable explicit instrumentation for memory barriers. KCSAN_INSTRUMENT_BARRIERS := y
@@ -22,9 +18,6 @@ KCSAN_INSTRUMENT_BARRIERS := y # flaky coverage that is not a function of syscall inputs. E.g. slab is out of # free pages, or a task is migrated between nodes. KCOV_INSTRUMENT_slab_common.o := n -KCOV_INSTRUMENT_slob.o := n -KCOV_INSTRUMENT_slab.o := n -KCOV_INSTRUMENT_slub.o := n KCOV_INSTRUMENT_page_alloc.o := n KCOV_INSTRUMENT_debug-pagealloc.o := n KCOV_INSTRUMENT_kmemleak.o := n
@@ -81,12 +74,9 @@ obj-$(CONFIG_HUGETLB_PAGE_OPTIMIZE_VMEMMAP) += hugetlb_vmemmap.o obj-$(CONFIG_NUMA) += mempolicy.o obj-$(CONFIG_SPARSEMEM) += sparse.o obj-$(CONFIG_SPARSEMEM_VMEMMAP) += sparse-vmemmap.o -obj-$(CONFIG_SLOB) += slob.o obj-$(CONFIG_MMU_NOTIFIER) += mmu_notifier.o obj-$(CONFIG_KSM) += ksm.o obj-$(CONFIG_PAGE_POISONING) += page_poison.o -obj-$(CONFIG_SLAB) += slab.o -obj-$(CONFIG_SLUB) += slub.o obj-$(CONFIG_KASAN) += kasan/ obj-$(CONFIG_KFENCE) += kfence/ obj-$(CONFIG_KMSAN) += kmsan/
mm/slab.c deleted +0 -4046
2,207 lines not on this page · raw message
mm/slab.h +0 -426
426 lines not on this page · raw message
mm/slab_common.c +216 -660
876 lines not on this page · raw message
mm/slob.c deleted +0 -757
757 lines not on this page · raw message
mm/slub.c deleted +0 -6506
6,506 lines not on this page · raw message
The rest of this diff is not shown. View the raw message.
Signature · 1 line
2.40.0
Part of the diff is not shown here. View the raw message.
Quoted 13,774 lines · Vlastimil Babka
As the SLOB removal is on track and the SLAB removal is planned, I have realized - why should we stop there and not remove also SLUB? What's a slab allocator good for in 2023? The RAM sizes are getting larger and the modules cheaper [1]. The object constructor trick was perhaps interesting in 1994, but not with contemporary CPUs. So all the slab allocator does today is just adding an unnecessary layer of complexity over the page allocator.
Thus, with this patch, all three slab allocators are removed, and only a layer that passes everything to the page allocator remains in the
slab.handmm/slab_common.cfiles. This will allow users to gradually transition away and use the page allocator directly. To summarize the advantages:- Less code to maintain: over 13k lines are removed by this patch, and more could be removed if I wast^Wspent more time on this, and later as users are transitioned from the legacy layer. This no longer needs a separate subsystem so remove it from
MAINTAINERS(I hope I can keep the kernel.org account anyway, though).- Simplified
MEMCG_KMEMaccounting: while I was lazy and just marked it BROKEN in this patch, it should be trivial to use the page memcg accounting now that we use the page allocator. The per-object accounting went through several iterations in the past and was always complex and added overhead. Page accounting is much simpler by comparison.- Simplified KASAN and friends: also was lazy in this patch so they can't be enabled but should be easy to fix up and work just on the page level.
- Simpler debugging: just use debug_pagealloc=on, no need to look up the exact syntax of the absurdly complex
slub_debugparameter.- Speed: didn't measure, but for the page allocator we have pcplists, so it should scale just fine. No need for the crazy SLUB's
cmpxchg_double()craziness. Maybe that thing could be now removed too? Yeah I can see just two remaining users.Any downsides? Let's look at memory usage after virtme boot:
Before (with SLUB):
Slab: 26304 kBAfter:
Slab: 295592 kBWell, that's not so bad, see [1].
[1] https://www.theregister.com/2023/03/29/dram_prices_crash/
--- MAINTAINERS | 15 - include/linux/slab.h | 211 +- include/linux/slab_def.h | 124 - include/linux/slub_def.h | 198 -- init/Kconfig | 2 +- mm/Kconfig | 134 +- mm/Makefile | 10 - mm/slab.c | 4046 ------------------------ mm/slab.h | 426 --- mm/slab_common.c | 876 ++--- mm/slob.c | 757 ----- mm/slub.c | 6506 -------------------------------------- 12 files changed, 228 insertions(+), 13077 deletions(-) delete mode 100644 include/linux/slab_def.h delete mode 100644 include/linux/slub_def.h delete mode 100644 mm/slab.c delete mode 100644 mm/slob.c delete mode 100644 mm/slub.cMAINTAINERS +0
-15@@ -19183,21 +19183,6 @@ F: drivers/irqchip/irq-sl28cpld.c F: drivers/pwm/pwm-sl28cpld.c F: drivers/watchdog/sl28cpld_wdt.c -SLAB ALLOCATOR -M: Christoph Lameter <[email protected]> -M: Pekka Enberg <[email protected]> -M: David Rientjes <[email protected]> -M: Joonsoo Kim <[email protected]> -M: Andrew Morton <[email protected]> -M: Vlastimil Babka <[email protected]> -R: Roman Gushchin <[email protected]> -R: Hyeonggon Yoo <[email protected]> -L: [email protected] -S: Maintained -T: git git://git.kernel.org/pub/scm/linux/kernel/git/vbabka/slab.git -F: include/linux/sl?b*.h -F: mm/sl?b* - SLCAN CAN NETWORK DRIVER M: Dario Binacchi <[email protected]> L: [email protected]include/linux/slab.h +7
-204@@ -140,13 +140,14 @@/* The following flags affect the page allocator grouping pages by mobility */ /* Objects are reclaimable */ -#ifndef CONFIG_SLUB_TINY #define SLAB_RECLAIM_ACCOUNT ((slab_flags_t __force)0x00020000U) -#else -#define SLAB_RECLAIM_ACCOUNT ((slab_flags_t __force)0) -#endif #define SLAB_TEMPORARY SLAB_RECLAIM_ACCOUNT/* Objects are short-lived */ +#define KMALLOC_NOT_NORMAL_BITS \ + (__GFP_RECLAIMABLE | \ + (IS_ENABLED(CONFIG_ZONE_DMA) ? __GFP_DMA : 0) | \ + (IS_ENABLED(CONFIG_MEMCG_KMEM) ? __GFP_ACCOUNT : 0)) +/* * ZERO_SIZE_PTR will be returned for zero sized kmalloc requests. * @@ -278,38 +279,11 @@ static inline unsigned int arch_slab_minalign(void)* Kmalloc array related definitions */ -#ifdef CONFIG_SLAB -/* -* SLAB and SLUB directly allocates requests fitting in to an order-1 page -* (PAGE_SIZE*2). Larger requests are passed to the page allocator. -*/ -#define KMALLOC_SHIFT_HIGH (PAGE_SHIFT + 1) -#define KMALLOC_SHIFT_MAX (MAX_ORDER + PAGE_SHIFT - 1) -#ifndef KMALLOC_SHIFT_LOW -#define KMALLOC_SHIFT_LOW 5 -#endif -#endif - -#ifdef CONFIG_SLUB -#define KMALLOC_SHIFT_HIGH (PAGE_SHIFT + 1) -#define KMALLOC_SHIFT_MAX (MAX_ORDER + PAGE_SHIFT - 1) -#ifndef KMALLOC_SHIFT_LOW -#define KMALLOC_SHIFT_LOW 3 -#endif -#endif - -#ifdef CONFIG_SLOB -/* -* SLOB passes all requests larger than one page to the page allocator. -* No kmalloc array is necessary since objects of different sizes can -* be allocated from the same page. -*/ #define KMALLOC_SHIFT_HIGH PAGE_SHIFT#define KMALLOC_SHIFT_MAX (MAX_ORDER + PAGE_SHIFT - 1)#ifndef KMALLOC_SHIFT_LOW #define KMALLOC_SHIFT_LOW 3#endif -#endif /* Maximum allocatable size */ #define KMALLOC_MAX_SIZE (1UL << KMALLOC_SHIFT_MAX)@@ -336,130 +310,6 @@ static inline unsigned int arch_slab_minalign(void)#define SLAB_OBJ_MIN_SIZE (KMALLOC_MIN_SIZE < 16 ? \ (KMALLOC_MIN_SIZE) : 16) -/* -* Whenever changing this, take care of that kmalloc_type() and -* create_kmalloc_caches() still work as intended. -* -* KMALLOC_NORMAL can contain only unaccounted objects whereas KMALLOC_CGROUP -* is for accounted but unreclaimable and non-dma objects. All the other -* kmem caches can have both accounted and unaccounted objects. -*/ -enum kmalloc_cache_type { -KMALLOC_NORMAL =0 , -#ifndef CONFIG_ZONE_DMA -KMALLOC_DMA =KMALLOC_NORMAL , -#endif -#ifndef CONFIG_MEMCG_KMEM -KMALLOC_CGROUP =KMALLOC_NORMAL , -#endif -#ifdef CONFIG_SLUB_TINY -KMALLOC_RECLAIM =KMALLOC_NORMAL , -#else -KMALLOC_RECLAIM , -#endif -#ifdef CONFIG_ZONE_DMA -KMALLOC_DMA , -#endif -#ifdef CONFIG_MEMCG_KMEM -KMALLOC_CGROUP , -#endif -NR_KMALLOC_TYPES -}; - -#ifndef CONFIG_SLOB -extern struct kmem_cache * -kmalloc_caches[NR_KMALLOC_TYPES ][KMALLOC_SHIFT_HIGH +1 ]; - -/* -* Define gfp bits that should not be set for KMALLOC_NORMAL. -*/ -#define KMALLOC_NOT_NORMAL_BITS \ - (__GFP_RECLAIMABLE | \ - (IS_ENABLED(CONFIG_ZONE_DMA) ? __GFP_DMA : 0) | \ - (IS_ENABLED(CONFIG_MEMCG_KMEM) ? __GFP_ACCOUNT : 0)) - -static __always_inline enum kmalloc_cache_type kmalloc_type(gfp_t flags) -{ -/* -* The most common case is KMALLOC_NORMAL, so test for it -* with a single branch for all the relevant flags. -*/ -if (likely ((flags &KMALLOC_NOT_NORMAL_BITS ) ==0 )) -return KMALLOC_NORMAL ; - -/* -* At least one of the flags has to be set. Their priorities in -* decreasing order are: -* 1) __GFP_DMA -* 2) __GFP_RECLAIMABLE -* 3) __GFP_ACCOUNT -*/ -if (IS_ENABLED (CONFIG_ZONE_DMA ) && (flags & __GFP_DMA)) -return KMALLOC_DMA ; -if (!IS_ENABLED (CONFIG_MEMCG_KMEM ) || (flags & __GFP_RECLAIMABLE)) -return KMALLOC_RECLAIM ; -else -return KMALLOC_CGROUP ; -} - -/* -* Figure out which kmalloc slab an allocation of a certain size -* belongs to. -* 0 = zero alloc -* 1 = 65 .. 96 bytes -* 2 = 129 .. 192 bytes -* n = 2^(n-1)+1 .. 2^n -* -* Note: __kmalloc_index() is compile-time optimized, and not runtime optimized; -* typical usage is via kmalloc_index() and therefore evaluated at compile-time. -* Callers where !size_is_constant should only be test modules, where runtime -* overheads of __kmalloc_index() can be tolerated. Also see kmalloc_slab(). -*/ -static __always_inline unsigned int __kmalloc_index(size_t size, -bool size_is_constant) -{ -if (!size) -return 0 ; - -if (size <=KMALLOC_MIN_SIZE ) -return KMALLOC_SHIFT_LOW ; - -if (KMALLOC_MIN_SIZE <=32 && size >64 && size <=96 ) -return 1 ; -if (KMALLOC_MIN_SIZE <=64 && size >128 && size <=192 ) -return 2 ; -if (size <=8 )return 3 ; -if (size <=16 )return 4 ; -if (size <=32 )return 5 ; -if (size <=64 )return 6 ; -if (size <=128 )return 7 ; -if (size <=256 )return 8 ; -if (size <=512 )return 9 ; -if (size <=1024 )return 10 ; -if (size <=2 *1024 )return 11 ; -if (size <=4 *1024 )return 12 ; -if (size <=8 *1024 )return 13 ; -if (size <=16 *1024 )return 14 ; -if (size <=32 *1024 )return 15 ; -if (size <=64 *1024 )return 16 ; -if (size <=128 *1024 )return 17 ; -if (size <=256 *1024 )return 18 ; -if (size <=512 *1024 )return 19 ; -if (size <=1024 *1024 )return 20 ; -if (size <=2 *1024 *1024 )return 21 ; - -if (!IS_ENABLED (CONFIG_PROFILE_ALL_BRANCHES ) && size_is_constant) -BUILD_BUG_ON_MSG (1 ,"unexpected size in kmalloc_index()" ); -else -BUG (); - -/* Will never be reached. Needed because the compiler may complain */ -return -1 ; -} -static_assert (PAGE_SHIFT <=20 ); -#define kmalloc_index (s) __kmalloc_index(s, true) -#endif /* !CONFIG_SLOB */ -void *__kmalloc (size_t size,gfp_t flags) __assume_kmalloc_alignment__alloc_size(1) ;/** @@ -567,57 +417,15 @@ void *kmalloc_large_node(size_t size, gfp_t flags, int node) __assume_page_align* Try really hard to succeed the allocation but fail * eventually. */ -#ifndef CONFIG_SLOB -static __always_inline __alloc_size(1) void *kmalloc(size_t size, gfp_t flags) -{ -if (__builtin_constant_p (size) && size) { -unsigned int index; - -if (size >KMALLOC_MAX_CACHE_SIZE ) -return kmalloc_large (size, flags); - - index =kmalloc_index (size); -return kmalloc_trace ( - kmalloc_caches[kmalloc_type (flags)][index], - flags, size); - } -return __kmalloc (size, flags); -} -#else static __always_inline __alloc_size(1) void *kmalloc(size_t size, gfp_t flags) { -if (__builtin_constant_p (size) && size >KMALLOC_MAX_CACHE_SIZE ) -return kmalloc_large (size, flags); - -return __kmalloc (size, flags); +return kmalloc_large (size, flags); } -#endif -#ifndef CONFIG_SLOB static __always_inline __alloc_size(1) void *kmalloc_node(size_t size, gfp_t flags, int node) { -if (__builtin_constant_p (size) && size) { -unsigned int index; - -if (size >KMALLOC_MAX_CACHE_SIZE ) -return kmalloc_large_node (size, flags, node); - - index =kmalloc_index (size); -return kmalloc_node_trace ( - kmalloc_caches[kmalloc_type (flags)][index], - flags, node, size); - } -return __kmalloc_node (size, flags, node); +return kmalloc_large_node (size, flags, node); } -#else -static __always_inline __alloc_size(1) void *kmalloc_node(size_t size, gfp_t flags, int node) -{ -if (__builtin_constant_p (size) && size >KMALLOC_MAX_CACHE_SIZE ) -return kmalloc_large_node (size, flags, node); - -return __kmalloc_node (size, flags, node); -} -#endif /** * kmalloc_array - allocate memory for an array. @@ -785,12 +593,7 @@ size_t kmalloc_size_roundup(size_t size);void __init kmem_cache_init_late (void ); -#if defined(CONFIG_SMP ) && defined(CONFIG_SLAB ) -int slab_prepare_cpu (unsigned int cpu); -int slab_dead_cpu (unsigned int cpu); -#else #define slab_prepare_cpu NULL#define slab_dead_cpu NULL -#endif #endif /* _LINUX_SLAB_H */ include/linux/slab_def.h deleted +0
-124@@ -1,124 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0 */ -#ifndef _LINUX_SLAB_DEF_H -#define _LINUX_SLAB_DEF_H - -#include <linux/kfence.h> -#include <linux/reciprocal_div.h> - -/* -* Definitions unique to the original Linux SLAB allocator. -*/ - -struct kmem_cache { -struct array_cache __percpu *cpu_cache; - -/* 1) Cache tunables. Protected by slab_mutex */ -unsigned int batchcount; -unsigned int limit; -unsigned int shared; - -unsigned int size; -struct reciprocal_value reciprocal_buffer_size; -/* 2) touched by every alloc & free from the backend */ - -slab_flags_t flags;/* constant flags */ -unsigned int num;/* # of objs per slab */ - -/* 3) cache_grow/shrink */ -/* order of pgs per slab (2^n) */ -unsigned int gfporder; - -/* force GFP flags, e.g. GFP_DMA */ -gfp_t allocflags; - -size_t colour;/* cache colouring range */ -unsigned int colour_off;/* colour offset */ -unsigned int freelist_size; - -/* constructor func */ -void (*ctor)(void *obj); - -/* 4) cache creation/removal */ -const char *name; -struct list_head list; -int refcount; -int object_size; -int align; - -/* 5) statistics */ -#ifdef CONFIG_DEBUG_SLAB -unsigned long num_active; -unsigned long num_allocations; -unsigned long high_mark; -unsigned long grown; -unsigned long reaped; -unsigned long errors; -unsigned long max_freeable; -unsigned long node_allocs; -unsigned long node_frees; -unsigned long node_overflow; -atomic_t allochit; -atomic_t allocmiss; -atomic_t freehit; -atomic_t freemiss; - -/* -* If debugging is enabled, then the allocator can add additional -* fields and/or padding to every object. 'size' contains the total -* object size including these internal fields, while 'obj_offset' -* and 'object_size' contain the offset to the user object and its -* size. -*/ -int obj_offset; -#endif /* CONFIG_DEBUG_SLAB */ - -#ifdef CONFIG_KASAN_GENERIC -struct kasan_cache kasan_info; -#endif - -#ifdef CONFIG_SLAB_FREELIST_RANDOM -unsigned int *random_seq; -#endif - -#ifdef CONFIG_HARDENED_USERCOPY -unsigned int useroffset;/* Usercopy region offset */ -unsigned int usersize;/* Usercopy region size */ -#endif - -struct kmem_cache_node *node[MAX_NUMNODES ]; -}; - -static inline void *nearest_obj (struct kmem_cache *cache,const struct slab *slab, -void *x) -{ -void *object = x - (x - slab->s_mem) % cache->size; -void *last_object = slab->s_mem + (cache->num -1 ) * cache->size; - -if (unlikely (object > last_object)) -return last_object; -else -return object; -} - -/* -* We want to avoid an expensive divide : (offset / cache->size) -* Using the fact that size is a constant for a particular cache, -* we can replace (offset / cache->size) by -* reciprocal_divide(offset, cache->reciprocal_buffer_size) -*/ -static inline unsigned int obj_to_index (const struct kmem_cache *cache, -const struct slab *slab,void *obj) -{ -u32 offset = (obj - slab->s_mem); -return reciprocal_divide (offset, cache->reciprocal_buffer_size); -} - -static inline int objs_per_slab (const struct kmem_cache *cache, -const struct slab *slab) -{ -if (is_kfence_address (slab_address (slab))) -return 1 ; -return cache->num; -} - -#endif /* _LINUX_SLAB_DEF_H */ include/linux/slub_def.h deleted +0
-198@@ -1,198 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0 */ -#ifndef _LINUX_SLUB_DEF_H -#define _LINUX_SLUB_DEF_H - -/* -* SLUB : A Slab allocator without object queues. -* -* (C) 2007 SGI, Christoph Lameter -*/ -#include <linux/kfence.h> -#include <linux/kobject.h> -#include <linux/reciprocal_div.h> -#include <linux/local_lock.h> - -enum stat_item { -ALLOC_FASTPATH ,/* Allocation from cpu slab */ -ALLOC_SLOWPATH ,/* Allocation by getting a new cpu slab */ -FREE_FASTPATH ,/* Free to cpu slab */ -FREE_SLOWPATH ,/* Freeing not to cpu slab */ -FREE_FROZEN ,/* Freeing to frozen slab */ -FREE_ADD_PARTIAL ,/* Freeing moves slab to partial list */ -FREE_REMOVE_PARTIAL ,/* Freeing removes last object */ -ALLOC_FROM_PARTIAL ,/* Cpu slab acquired from node partial list */ -ALLOC_SLAB ,/* Cpu slab acquired from page allocator */ -ALLOC_REFILL ,/* Refill cpu slab from slab freelist */ -ALLOC_NODE_MISMATCH ,/* Switching cpu slab */ -FREE_SLAB ,/* Slab freed to the page allocator */ -CPUSLAB_FLUSH ,/* Abandoning of the cpu slab */ -DEACTIVATE_FULL ,/* Cpu slab was full when deactivated */ -DEACTIVATE_EMPTY ,/* Cpu slab was empty when deactivated */ -DEACTIVATE_TO_HEAD ,/* Cpu slab was moved to the head of partials */ -DEACTIVATE_TO_TAIL ,/* Cpu slab was moved to the tail of partials */ -DEACTIVATE_REMOTE_FREES ,/* Slab contained remotely freed objects */ -DEACTIVATE_BYPASS ,/* Implicit deactivation */ -ORDER_FALLBACK ,/* Number of times fallback was necessary */ -CMPXCHG_DOUBLE_CPU_FAIL ,/* Failure of this_cpu_cmpxchg_double */ -CMPXCHG_DOUBLE_FAIL ,/* Number of times that cmpxchg double did not match */ -CPU_PARTIAL_ALLOC ,/* Used cpu partial on alloc */ -CPU_PARTIAL_FREE ,/* Refill cpu partial on free */ -CPU_PARTIAL_NODE ,/* Refill cpu partial from node partial */ -CPU_PARTIAL_DRAIN ,/* Drain cpu partial to node partial */ -NR_SLUB_STAT_ITEMS }; - -#ifndef CONFIG_SLUB_TINY -/* -* When changing the layout, make sure freelist and tid are still compatible -* with this_cpu_cmpxchg_double() alignment requirements. -*/ -struct kmem_cache_cpu { -void **freelist;/* Pointer to next available object */ -unsigned long tid;/* Globally unique transaction id */ -struct slab *slab;/* The slab from which we are allocating */ -#ifdef CONFIG_SLUB_CPU_PARTIAL -struct slab *partial;/* Partially allocated frozen slabs */ -#endif -local_lock_t lock;/* Protects the fields above */ -#ifdef CONFIG_SLUB_STATS -unsigned stat[NR_SLUB_STAT_ITEMS ]; -#endif -}; -#endif /* CONFIG_SLUB_TINY */ - -#ifdef CONFIG_SLUB_CPU_PARTIAL -#define slub_percpu_partial (c) ((c)->partial) - -#define slub_set_percpu_partial (c, p) \ -({ \ - slub_percpu_partial(c) = (p)->next; \ -}) - -#define slub_percpu_partial_read_once (c) READ_ONCE(slub_percpu_partial(c)) -#else -#define slub_percpu_partial (c) NULL - -#define slub_set_percpu_partial (c, p) - -#define slub_percpu_partial_read_once (c) NULL -#endif // CONFIG_SLUB_CPU_PARTIAL - -/* -* Word size structure that can be atomically updated or read and that -* contains both the order and the number of objects that a slab of the -* given order would contain. -*/ -struct kmem_cache_order_objects { -unsigned int x; -}; - -/* -* Slab cache management. -*/ -struct kmem_cache { -#ifndef CONFIG_SLUB_TINY -struct kmem_cache_cpu __percpu *cpu_slab; -#endif -/* Used for retrieving partial slabs, etc. */ -slab_flags_t flags; -unsigned long min_partial; -unsigned int size;/* The size of an object including metadata */ -unsigned int object_size;/* The size of an object without metadata */ -struct reciprocal_value reciprocal_size; -unsigned int offset;/* Free pointer offset */ -#ifdef CONFIG_SLUB_CPU_PARTIAL -/* Number of per cpu partial objects to keep around */ -unsigned int cpu_partial; -/* Number of per cpu partial slabs to keep around */ -unsigned int cpu_partial_slabs; -#endif -struct kmem_cache_order_objects oo; - -/* Allocation and freeing of slabs */ -struct kmem_cache_order_objects min; -gfp_t allocflags;/* gfp flags to use on each alloc */ -int refcount;/* Refcount for slab cache destroy */ -void (*ctor)(void *); -unsigned int inuse;/* Offset to metadata */ -unsigned int align;/* Alignment */ -unsigned int red_left_pad;/* Left redzone padding size */ -const char *name;/* Name (only for display!) */ -struct list_head list;/* List of slab caches */ -#ifdef CONFIG_SYSFS -struct kobject kobj;/* For sysfs */ -#endif -#ifdef CONFIG_SLAB_FREELIST_HARDENED -unsigned long random; -#endif - -#ifdef CONFIG_NUMA -/* -* Defragmentation by allocating from a remote node. -*/ -unsigned int remote_node_defrag_ratio; -#endif - -#ifdef CONFIG_SLAB_FREELIST_RANDOM -unsigned int *random_seq; -#endif - -#ifdef CONFIG_KASAN_GENERIC -struct kasan_cache kasan_info; -#endif - -#ifdef CONFIG_HARDENED_USERCOPY -unsigned int useroffset;/* Usercopy region offset */ -unsigned int usersize;/* Usercopy region size */ -#endif - -struct kmem_cache_node *node[MAX_NUMNODES ]; -}; - -#if defined(CONFIG_SYSFS ) && !defined(CONFIG_SLUB_TINY ) -#define SLAB_SUPPORTS_SYSFS -void sysfs_slab_unlink (struct kmem_cache *); -void sysfs_slab_release (struct kmem_cache *); -#else -static inline void sysfs_slab_unlink (struct kmem_cache *s) -{ -} -static inline void sysfs_slab_release (struct kmem_cache *s) -{ -} -#endif - -void *fixup_red_left (struct kmem_cache *s,void *p); - -static inline void *nearest_obj (struct kmem_cache *cache,const struct slab *slab, -void *x) { -void *object = x - (x -slab_address (slab)) % cache->size; -void *last_object =slab_address (slab) + - (slab->objects -1 ) * cache->size; -void *result = (unlikely (object > last_object)) ? last_object : object; - - result =fixup_red_left (cache, result); -return result; -} - -/* Determine object index from a given position */ -static inline unsigned int __obj_to_index (const struct kmem_cache *cache, -void *addr,void *obj) -{ -return reciprocal_divide (kasan_reset_tag (obj) - addr, - cache->reciprocal_size); -} - -static inline unsigned int obj_to_index (const struct kmem_cache *cache, -const struct slab *slab,void *obj) -{ -if (is_kfence_address (obj)) -return 0 ; -return __obj_to_index (cache,slab_address (slab), obj); -} - -static inline int objs_per_slab (const struct kmem_cache *cache, -const struct slab *slab) -{ -return slab->objects; -} -#endif /* _LINUX_SLUB_DEF_H */ init/Kconfig +1
-1@@ -973,7 +973,7 @@ config MEMCG config MEMCG_KMEM bool - depends on MEMCG && !SLOB + depends on MEMCG && BROKEN default y config BLK_CGROUPmm/Kconfig +4
-130@@ -210,134 +210,9 @@ config ZSMALLOC_CHAIN_SIZE For more information, see zsmalloc documentation. -menu "SLAB allocator options" - -choice - prompt "Choose SLAB allocator" - default SLUB - help - This option allows to select a slab allocator. - -config SLAB - bool "SLAB" - depends on !PREEMPT_RT - select HAVE_HARDENED_USERCOPY_ALLOCATOR - help - The regular slab allocator that is established and known to work - well in all environments. It organizes cache hot objects in - per cpu and per node queues. - -config SLUB - bool "SLUB (Unqueued Allocator)" - select HAVE_HARDENED_USERCOPY_ALLOCATOR - help - SLUB is a slab allocator that minimizes cache line usage - instead of managing queues of cached objects (SLAB approach). - Per cpu caching is realized using slabs of objects instead - of queues of objects. SLUB can use memory efficiently - and has enhanced diagnostics. SLUB is the default choice for - a slab allocator. - -config SLOB_DEPRECATED - depends on EXPERT - bool "SLOB (Simple Allocator - DEPRECATED)" - depends on !PREEMPT_RT - help - Deprecated and scheduled for removal in a few cycles. SLUB - recommended as replacement. CONFIG_SLUB_TINY can be considered - on systems with 16MB or less RAM. - - If you need SLOB to stay, please contact [email protected] and - people listed in the SLAB ALLOCATOR section of MAINTAINERS file, - with your use case. - - SLOB replaces the stock allocator with a drastically simpler - allocator. SLOB is generally more space efficient but - does not perform as well on large systems. - -endchoice - -config SLOB - bool - default y - depends on SLOB_DEPRECATED - -config SLUB_TINY - bool "Configure SLUB for minimal memory footprint" - depends on SLUB && EXPERT - select SLAB_MERGE_DEFAULT - help - Configures the SLUB allocator in a way to achieve minimal memory - footprint, sacrificing scalability, debugging and other features. - This is intended only for the smallest system that had used the - SLOB allocator and is not recommended for systems with more than - 16MB RAM. - - If unsure, say N. - -config SLAB_MERGE_DEFAULT - bool "Allow slab caches to be merged" - default y - depends on SLAB || SLUB - help - For reduced kernel memory fragmentation, slab caches can be - merged when they share the same size and other characteristics. - This carries a risk of kernel heap overflows being able to - overwrite objects from merged caches (and more easily control - cache layout), which makes such heap attacks easier to exploit - by attackers. By keeping caches unmerged, these kinds of exploits - can usually only damage objects in the same cache. To disable - merging at runtime, "slab_nomerge" can be passed on the kernel - command line. - -config SLAB_FREELIST_RANDOM - bool "Randomize slab freelist" - depends on SLAB || (SLUB && !SLUB_TINY) - help - Randomizes the freelist order used on creating new pages. This - security feature reduces the predictability of the kernel slab - allocator against heap overflows. - -config SLAB_FREELIST_HARDENED - bool "Harden slab freelist metadata" - depends on SLAB || (SLUB && !SLUB_TINY) - help - Many kernel heap attacks try to target slab cache metadata and - other infrastructure. This options makes minor performance - sacrifices to harden the kernel slab allocator against common - freelist exploit methods. Some slab implementations have more - sanity-checking than others. This option is most effective with - CONFIG_SLUB. - -config SLUB_STATS - default n - bool "Enable SLUB performance statistics" - depends on SLUB && SYSFS && !SLUB_TINY - help - SLUB statistics are useful to debug SLUBs allocation behavior in - order find ways to optimize the allocator. This should never be - enabled for production use since keeping statistics slows down - the allocator by a few percentage points. The slabinfo command - supports the determination of the most active slabs to figure - out which slabs are relevant to a particular load. - Try running: slabinfo -DA - -config SLUB_CPU_PARTIAL - default y - depends on SLUB && SMP && !SLUB_TINY - bool "SLUB per cpu partial cache" - help - Per cpu partial caches accelerate objects allocation and freeing - that is local to a processor at the price of more indeterminism - in the latency of the free. On overflow these caches will be cleared - which requires the taking of locks that may cause latency spikes. - Typically one would choose no for a realtime system. - -endmenu # SLAB allocator options - config SHUFFLE_PAGE_ALLOCATOR bool "Page allocator randomization" - default SLAB_FREELIST_RANDOM && ACPI_NUMA + default ACPI_NUMA help Randomization of the page allocator improves the average utilization of a direct-mapped memory-side-cache. See section@@ -345,10 +220,9 @@ config SHUFFLE_PAGE_ALLOCATOR 6.2a specification for an example of how a platform advertises the presence of a memory-side-cache. There are also incidental security benefits as it reduces the predictability of page - allocations to compliment SLAB_FREELIST_RANDOM, but the - default granularity of shuffling on the "MAX_ORDER - 1" i.e, - 10th order of pages is selected based on cache utilization - benefits on x86. + allocations, but the default granularity of shuffling on the + "MAX_ORDER - 1" i.e, 10th order of pages is selected based on + cache utilization benefits on x86. While the randomization improves cache utilization it may negatively impact workloads on platforms without a cache. Formm/Makefile +0
-10@@ -4,16 +4,12 @@ # KASAN_SANITIZE_slab_common.o := n -KASAN_SANITIZE_slab.o := n -KASAN_SANITIZE_slub.o := n KCSAN_SANITIZE_kmemleak.o := n # These produce frequent data race reports: most of them are due to races on # the same word but accesses to different bits of that word. Re-enable KCSAN # for these when we have more consensus on what to do about them. KCSAN_SANITIZE_slab_common.o := n -KCSAN_SANITIZE_slab.o := n -KCSAN_SANITIZE_slub.o := n KCSAN_SANITIZE_page_alloc.o := n # But enable explicit instrumentation for memory barriers. KCSAN_INSTRUMENT_BARRIERS := y@@ -22,9 +18,6 @@ KCSAN_INSTRUMENT_BARRIERS := y # flaky coverage that is not a function of syscall inputs. E.g. slab is out of # free pages, or a task is migrated between nodes. KCOV_INSTRUMENT_slab_common.o := n -KCOV_INSTRUMENT_slob.o := n -KCOV_INSTRUMENT_slab.o := n -KCOV_INSTRUMENT_slub.o := n KCOV_INSTRUMENT_page_alloc.o := n KCOV_INSTRUMENT_debug-pagealloc.o := n KCOV_INSTRUMENT_kmemleak.o := n@@ -81,12 +74,9 @@ obj-$(CONFIG_HUGETLB_PAGE_OPTIMIZE_VMEMMAP) += hugetlb_vmemmap.o obj-$(CONFIG_NUMA) += mempolicy.o obj-$(CONFIG_SPARSEMEM) += sparse.o obj-$(CONFIG_SPARSEMEM_VMEMMAP) += sparse-vmemmap.o -obj-$(CONFIG_SLOB) += slob.o obj-$(CONFIG_MMU_NOTIFIER) += mmu_notifier.o obj-$(CONFIG_KSM) += ksm.o obj-$(CONFIG_PAGE_POISONING) += page_poison.o -obj-$(CONFIG_SLAB) += slab.o -obj-$(CONFIG_SLUB) += slub.o obj-$(CONFIG_KASAN) += kasan/ obj-$(CONFIG_KFENCE) += kfence/ obj-$(CONFIG_KMSAN) += kmsan/mm/slab.c deleted +0
-4046@@ -1,4046 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0 -/* -* linux/mm/slab.c -* Written by Mark Hemment, 1996/97. -* ([email protected]) -* -* kmem_cache_destroy() + some cleanup - 1999 Andrea Arcangeli -* -* Major cleanup, different bufctl logic, per-cpu arrays -* (c) 2000 Manfred Spraul -* -* Cleanup, make the head arrays unconditional, preparation for NUMA -* (c) 2002 Manfred Spraul -* -* An implementation of the Slab Allocator as described in outline in; -* UNIX Internals: The New Frontiers by Uresh Vahalia -* Pub: Prentice Hall ISBN 0-13-101908-2 -* or with a little more detail in; -* The Slab Allocator: An Object-Caching Kernel Memory Allocator -* Jeff Bonwick (Sun Microsystems). -* Presented at: USENIX Summer 1994 Technical Conference -* -* The memory is organized in caches, one cache for each object type. -* (e.g. inode_cache, dentry_cache, buffer_head, vm_area_struct) -* Each cache consists out of many slabs (they are small (usually one -* page long) and always contiguous), and each slab contains multiple -* initialized objects. -* -* This means, that your constructor is used only for newly allocated -* slabs and you must pass objects with the same initializations to -* kmem_cache_free. -* -* Each cache can only support one memory type (GFP_DMA, GFP_HIGHMEM, -* normal). If you need a special memory type, then must create a new -* cache for that memory type. -* -* In order to reduce fragmentation, the slabs are sorted in 3 groups: -* full slabs with 0 free objects -* partial slabs -* empty slabs with no allocated objects -* -* If partial slabs exist, then new allocations come from these slabs, -* otherwise from empty slabs or new slabs are allocated. -* -* kmem_cache_destroy() CAN CRASH if you try to allocate from the cache -* during kmem_cache_destroy(). The caller must prevent concurrent allocs. -* -* Each cache has a short per-cpu head array, most allocs -* and frees go into that array, and if that array overflows, then 1/2 -* of the entries in the array are given back into the global cache. -* The head array is strictly LIFO and should improve the cache hit rates. -* On SMP, it additionally reduces the spinlock operations. -* -* The c_cpuarray may not be read with enabled local interrupts - -* it's changed with a smp_call_function(). -* -* SMP synchronization: -* constructors and destructors are called without any locking. -* Several members in struct kmem_cache and struct slab never change, they -* are accessed without any locking. -* The per-cpu arrays are never accessed from the wrong cpu, no locking, -* and local interrupts are disabled so slab code is preempt-safe. -* The non-constant members are protected with a per-cache irq spinlock. -* -* Many thanks to Mark Hemment, who wrote another per-cpu slab patch -* in 2000 - many ideas in the current implementation are derived from -* his patch. -* -* Further notes from the original documentation: -* -* 11 April '97. Started multi-threading - markhe -* The global cache-chain is protected by the mutex 'slab_mutex'. -* The sem is only needed when accessing/extending the cache-chain, which -* can never happen inside an interrupt (kmem_cache_create(), -* kmem_cache_shrink() and kmem_cache_reap()). -* -* At present, each engine can be growing a cache. This should be blocked. -* -* 15 March 2005. NUMA slab allocator. -* Shai Fultheim <[email protected]>. -* Shobhit Dayal <[email protected]> -* Alok N Kataria <[email protected]> -* Christoph Lameter <[email protected]> -* -* Modified the slab allocator to be node aware on NUMA systems. -* Each node has its own list of partial, free and full slabs. -* All object allocations for a node occur from node specific slab lists. -*/ - -#include <linux/slab.h> -#include <linux/mm.h> -#include <linux/poison.h> -#include <linux/swap.h> -#include <linux/cache.h> -#include <linux/interrupt.h> -#include <linux/init.h> -#include <linux/compiler.h> -#include <linux/cpuset.h> -#include <linux/proc_fs.h> -#include <linux/seq_file.h> -#include <linux/notifier.h> -#include <linux/kallsyms.h> -#include <linux/kfence.h> -#include <linux/cpu.h> -#include <linux/sysctl.h> -#include <linux/module.h> -#include <linux/rcupdate.h> -#include <linux/string.h> -#include <linux/uaccess.h> -#include <linux/nodemask.h> -#include <linux/kmemleak.h> -#include <linux/mempolicy.h> -#include <linux/mutex.h> -#include <linux/fault-inject.h> -#include <linux/rtmutex.h> -#include <linux/reciprocal_div.h> -#include <linux/debugobjects.h> -#include <linux/memory.h> -#include <linux/prefetch.h> -#include <linux/sched/task_stack.h> - -#include <net/sock.h> - -#include <asm/cacheflush.h> -#include <asm/tlbflush.h> -#include <asm/page.h> - -#include <trace/events/kmem.h> - -#include "internal.h" - -#include "slab.h" - -/* -* DEBUG - 1 for kmem_cache_create() to honour; SLAB_RED_ZONE & SLAB_POISON. -* 0 for faster, smaller code (especially in the critical paths). -* -* STATS - 1 to collect stats for /proc/slabinfo. -* 0 for faster, smaller code (especially in the critical paths). -* -* FORCED_DEBUG - 1 enables SLAB_RED_ZONE and SLAB_POISON (if possible) -*/ - -#ifdef CONFIG_DEBUG_SLAB -#define DEBUG 1 -#define STATS 1 -#define FORCED_DEBUG 1 -#else -#define DEBUG 0 -#define STATS 0 -#define FORCED_DEBUG 0 -#endif - -/* Shouldn't this be in a header file somewhere? */ -#define BYTES_PER_WORD sizeof(void *) -#define REDZONE_ALIGN max(BYTES_PER_WORD, __alignof__(unsigned long long)) - -#ifndef ARCH_KMALLOC_FLAGS -#define ARCH_KMALLOC_FLAGS SLAB_HWCACHE_ALIGN -#endif - -#define FREELIST_BYTE_INDEX (((PAGE_SIZE >> BITS_PER_BYTE) \ - <= SLAB_OBJ_MIN_SIZE) ? 1 : 0) - -#if FREELIST_BYTE_INDEX -typedef unsigned char freelist_idx_t ; -#else -typedef unsigned short freelist_idx_t ; -#endif - -#define SLAB_OBJ_MAX_NUM ((1 << sizeof(freelist_idx_t) * BITS_PER_BYTE) - 1) - -/* -* struct array_cache -* -* Purpose: -* - LIFO ordering, to hand out cache-warm objects from _alloc -* - reduce the number of linked list operations -* - reduce spinlock operations -* -* The limit is stored in the per-cpu structure to reduce the data cache -* footprint. -* -*/ -struct array_cache { -unsigned int avail; -unsigned int limit; -unsigned int batchcount; -unsigned int touched; -void *entry[];/* -* Must have this definition in here for the proper -* alignment of array_cache. Also simplifies accessing -* the entries. -*/ -}; - -struct alien_cache { -spinlock_t lock; -struct array_cache ac; -}; - -/* -* Need this for bootstrapping a per node allocator. -*/ -#define NUM_INIT_LISTS (2 * MAX_NUMNODES) -static struct kmem_cache_node __initdata init_kmem_cache_node[NUM_INIT_LISTS ]; -#define CACHE_CACHE 0 -#define SIZE_NODE (MAX_NUMNODES) - -static int drain_freelist (struct kmem_cache *cache, -struct kmem_cache_node *n,int tofree); -static void free_block (struct kmem_cache *cachep,void **objpp,int len, -int node,struct list_head *list); -static void slabs_destroy (struct kmem_cache *cachep,struct list_head *list); -static int enable_cpucache (struct kmem_cache *cachep,gfp_t gfp); -static void cache_reap (struct work_struct *unused); - -static inline void fixup_objfreelist_debug (struct kmem_cache *cachep, -void **list); -static inline void fixup_slab_list (struct kmem_cache *cachep, -struct kmem_cache_node *n,struct slab *slab, -void **list); - -#define INDEX_NODE kmalloc_index(sizeof(struct kmem_cache_node)) - -static void kmem_cache_node_init (struct kmem_cache_node *parent) -{ -INIT_LIST_HEAD (&parent->slabs_full); -INIT_LIST_HEAD (&parent->slabs_partial); -INIT_LIST_HEAD (&parent->slabs_free); - parent->total_slabs =0 ; - parent->free_slabs =0 ; - parent->shared =NULL ; - parent->alien =NULL ; - parent->colour_next =0 ; -raw_spin_lock_init (&parent->list_lock); - parent->free_objects =0 ; - parent->free_touched =0 ; -} - -#define MAKE_LIST (cachep, listp, slab, nodeid) \ - do { \ - INIT_LIST_HEAD(listp); \ - list_splice(&get_node(cachep, nodeid)->slab, listp); \ - } while (0) - -#define MAKE_ALL_LISTS (cachep, ptr, nodeid) \ - do { \ - MAKE_LIST((cachep), (&(ptr)->slabs_full), slabs_full, nodeid); \ - MAKE_LIST((cachep), (&(ptr)->slabs_partial), slabs_partial, nodeid); \ - MAKE_LIST((cachep), (&(ptr)->slabs_free), slabs_free, nodeid); \ - } while (0) - -#define CFLGS_OBJFREELIST_SLAB ((slab_flags_t __force)0x40000000U) -#define CFLGS_OFF_SLAB ((slab_flags_t __force)0x80000000U) -#define OBJFREELIST_SLAB (x) ((x)->flags & CFLGS_OBJFREELIST_SLAB) -#define OFF_SLAB (x) ((x)->flags & CFLGS_OFF_SLAB) - -#define BATCHREFILL_LIMIT 16 -/* -* Optimization question: fewer reaps means less probability for unnecessary -* cpucache drain/refill cycles. -* -* OTOH the cpuarrays can contain lots of objects, -* which could lock up otherwise freeable slabs. -*/ -#define REAPTIMEOUT_AC (2*HZ) -#define REAPTIMEOUT_NODE (4*HZ) - -#if STATS -#define STATS_INC_ACTIVE (x) ((x)->num_active++) -#define STATS_DEC_ACTIVE (x) ((x)->num_active--) -#define STATS_INC_ALLOCED (x) ((x)->num_allocations++) -#define STATS_INC_GROWN (x) ((x)->grown++) -#define STATS_ADD_REAPED (x, y) ((x)->reaped += (y)) -#define STATS_SET_HIGH (x) \ - do { \ - if ((x)->num_active > (x)->high_mark) \ - (x)->high_mark = (x)->num_active; \ - } while (0) -#define STATS_INC_ERR (x) ((x)->errors++) -#define STATS_INC_NODEALLOCS (x) ((x)->node_allocs++) -#define STATS_INC_NODEFREES (x) ((x)->node_frees++) -#define STATS_INC_ACOVERFLOW (x) ((x)->node_overflow++) -#define STATS_SET_FREEABLE (x, i) \ - do { \ - if ((x)->max_freeable < i) \ - (x)->max_freeable = i; \ - } while (0) -#define STATS_INC_ALLOCHIT (x) atomic_inc(&(x)->allochit) -#define STATS_INC_ALLOCMISS (x) atomic_inc(&(x)->allocmiss) -#define STATS_INC_FREEHIT (x) atomic_inc(&(x)->freehit) -#define STATS_INC_FREEMISS (x) atomic_inc(&(x)->freemiss) -#else -#define STATS_INC_ACTIVE (x) do { } while (0) -#define STATS_DEC_ACTIVE (x) do { } while (0) -#define STATS_INC_ALLOCED (x) do { } while (0) -#define STATS_INC_GROWN (x) do { } while (0) -#define STATS_ADD_REAPED (x, y) do { (void)(y); } while (0) -#define STATS_SET_HIGH (x) do { } while (0) -#define STATS_INC_ERR (x) do { } while (0) -#define STATS_INC_NODEALLOCS (x) do { } while (0) -#define STATS_INC_NODEFREES (x) do { } while (0) -#define STATS_INC_ACOVERFLOW (x) do { } while (0) -#define STATS_SET_FREEABLE (x, i) do { } while (0) -#define STATS_INC_ALLOCHIT (x) do { } while (0) -#define STATS_INC_ALLOCMISS (x) do { } while (0) -#define STATS_INC_FREEHIT (x) do { } while (0) -#define STATS_INC_FREEMISS (x) do { } while (0) -#endif - -#if DEBUG - -/* -* memory layout of objects: -* 0 : objp -* 0 .. cachep->obj_offset - BYTES_PER_WORD - 1: padding. This ensures that -* the end of an object is aligned with the end of the real -* allocation. Catches writes behind the end of the allocation. -* cachep->obj_offset - BYTES_PER_WORD .. cachep->obj_offset - 1: -* redzone word. -* cachep->obj_offset: The real object. -* cachep->size - 2* BYTES_PER_WORD: redzone word [BYTES_PER_WORD long] -* cachep->size - 1* BYTES_PER_WORD: last caller address -* [BYTES_PER_WORD long] -*/ -static int obj_offset (struct kmem_cache *cachep) -{ -return cachep->obj_offset; -} - -static unsigned long long *dbg_redzone1 (struct kmem_cache *cachep,void *objp) -{ -BUG_ON (!(cachep->flags &SLAB_RED_ZONE )); -return (unsigned long long *) (objp +obj_offset (cachep) - -sizeof (unsigned long long )); -} - -static unsigned long long *dbg_redzone2 (struct kmem_cache *cachep,void *objp) -{ -BUG_ON (!(cachep->flags &SLAB_RED_ZONE )); -if (cachep->flags &SLAB_STORE_USER ) -return (unsigned long long *)(objp + cachep->size - -sizeof (unsigned long long ) - -REDZONE_ALIGN ); -return (unsigned long long *) (objp + cachep->size - -sizeof (unsigned long long )); -} - -static void **dbg_userword (struct kmem_cache *cachep,void *objp) -{ -BUG_ON (!(cachep->flags &SLAB_STORE_USER )); -return (void **)(objp + cachep->size -BYTES_PER_WORD ); -} - -#else - -#define obj_offset (x) 0 -#define dbg_redzone1 (cachep, objp) ({BUG(); (unsigned long long *)NULL;}) -#define dbg_redzone2 (cachep, objp) ({BUG(); (unsigned long long *)NULL;}) -#define dbg_userword (cachep, objp) ({BUG(); (void **)NULL;}) - -#endif - -/* -* Do not go above this order unless 0 objects fit into the slab or -* overridden on the command line. -*/ -#define SLAB_MAX_ORDER_HI 1 -#define SLAB_MAX_ORDER_LO 0 -static int slab_max_order =SLAB_MAX_ORDER_LO ; -static bool slab_max_order_set__initdata ; - -static inline void *index_to_obj (struct kmem_cache *cache, -const struct slab *slab,unsigned int idx) -{ -return slab->s_mem + cache->size * idx; -} - -#define BOOT_CPUCACHE_ENTRIES 1 -/* internal cache of cache description objs */ -static struct kmem_cache kmem_cache_boot = { - .batchcount =1 , - .limit =BOOT_CPUCACHE_ENTRIES , - .shared =1 , - .size =sizeof (struct kmem_cache ), - .name ="kmem_cache" , -}; - -static DEFINE_PER_CPU(struct delayed_work, slab_reap_work); - -static inline struct array_cache *cpu_cache_get (struct kmem_cache *cachep) -{ -return this_cpu_ptr (cachep->cpu_cache); -} - -/* -* Calculate the number of objects and left-over bytes for a given buffer size. -*/ -static unsigned int cache_estimate (unsigned long gfporder,size_t buffer_size, -slab_flags_t flags,size_t *left_over) -{ -unsigned int num; -size_t slab_size =PAGE_SIZE << gfporder; - -/* -* The slab management structure can be either off the slab or -* on it. For the latter case, the memory allocated for a -* slab is used for: -* -* - @buffer_size bytes for each object -* - One freelist_idx_t for each object -* -* We don't need to consider alignment of freelist because -* freelist will be at the end of slab page. The objects will be -* at the correct alignment. -* -* If the slab management structure is off the slab, then the -* alignment will already be calculated into the size. Because -* the slabs are all pages aligned, the objects will be at the -* correct alignment when allocated. -*/ -if (flags & (CFLGS_OBJFREELIST_SLAB |CFLGS_OFF_SLAB )) { - num = slab_size / buffer_size; - *left_over = slab_size % buffer_size; - }else { - num = slab_size / (buffer_size +sizeof (freelist_idx_t)); - *left_over = slab_size % - (buffer_size +sizeof (freelist_idx_t)); - } - -return num; -} - -#if DEBUG -#define slab_error (cachep, msg) __slab_error(__func__, cachep, msg) - -static void __slab_error (const char *function,struct kmem_cache *cachep, -char *msg) -{ -pr_err ("slab error in %s(): cache `%s': %s\n" , - function, cachep->name, msg); -dump_stack (); -add_taint (TAINT_BAD_PAGE ,LOCKDEP_NOW_UNRELIABLE ); -} -#endif - -/* -* By default on NUMA we use alien caches to stage the freeing of -* objects allocated from other nodes. This causes massive memory -* inefficiencies when using fake NUMA setup to split memory into a -* large number of small nodes, so it can be disabled on the command -* line -*/ - -static int use_alien_caches__read_mostly =1 ; -static int __init noaliencache_setup (char *s) -{ - use_alien_caches =0 ; -return 1 ; -} -__setup ("noaliencache" , noaliencache_setup); - -static int __init slab_max_order_setup (char *str) -{ -get_option (&str, &slab_max_order); - slab_max_order = slab_max_order <0 ?0 : -min (slab_max_order,MAX_ORDER -1 ); - slab_max_order_set = true; - -return 1 ; -} -__setup ("slab_max_order=" , slab_max_order_setup); - -#ifdef CONFIG_NUMA -/* -* Special reaping functions for NUMA systems called from cache_reap(). -* These take care of doing round robin flushing of alien caches (containing -* objects freed on different nodes from which they were allocated) and the -* flushing of remote pcps by calling drain_node_pages. -*/ -static DEFINE_PER_CPU(unsigned long, slab_reap_node); - -static void init_reap_node (int cpu) -{ -per_cpu (slab_reap_node, cpu) =next_node_in (cpu_to_mem (cpu), - node_online_map); -} - -static void next_reap_node (void ) -{ -int node =__this_cpu_read (slab_reap_node); - - node =next_node_in (node, node_online_map); -__this_cpu_write (slab_reap_node, node); -} - -#else -#define init_reap_node (cpu) do { } while (0) -#define next_reap_node (void) do { } while (0) -#endif - -/* -* Initiate the reap timer running on the target CPU. We run at around 1 to 2Hz -* via the workqueue/eventd. -* Add the CPU number into the expiration time to minimize the possibility of -* the CPUs getting into lockstep and contending for the global cache chain -* lock. -*/ -static void start_cpu_timer (int cpu) -{ -struct delayed_work *reap_work = &per_cpu (slab_reap_work, cpu); - -if (reap_work->work.func ==NULL ) { -init_reap_node (cpu); -INIT_DEFERRABLE_WORK (reap_work, cache_reap); -schedule_delayed_work_on (cpu, reap_work, -__round_jiffies_relative (HZ , cpu)); - } -} - -static void init_arraycache (struct array_cache *ac,int limit,int batch) -{ -if (ac) { - ac->avail =0 ; - ac->limit = limit; - ac->batchcount = batch; - ac->touched =0 ; - } -} - -static struct array_cache *alloc_arraycache (int node,int entries, -int batchcount,gfp_t gfp) -{ -size_t memsize =sizeof (void *) * entries +sizeof (struct array_cache ); -struct array_cache *ac =NULL ; - - ac =kmalloc_node (memsize, gfp, node); -/* -* The array_cache structures contain pointers to free object. -* However, when such objects are allocated or transferred to another -* cache the pointers are not cleared and they could be counted as -* valid references during a kmemleak scan. Therefore, kmemleak must -* not scan such objects. -*/ -kmemleak_no_scan (ac); -init_arraycache (ac, entries, batchcount); -return ac; -} - -static noinline void cache_free_pfmemalloc(struct kmem_cache *cachep, -struct slab *slab,void *objp) -{ -struct kmem_cache_node *n; -int slab_node; -LIST_HEAD (list); - - slab_node =slab_nid (slab); - n =get_node (cachep, slab_node); - -raw_spin_lock (&n->list_lock); -free_block (cachep, &objp,1 , slab_node, &list); -raw_spin_unlock (&n->list_lock); - -slabs_destroy (cachep, &list); -} - -/* -* Transfer objects in one arraycache to another. -* Locking must be handled by the caller. -* -* Return the number of entries transferred. -*/ -static int transfer_objects (struct array_cache *to, -struct array_cache *from,unsigned int max) -{ -/* Figure out how many entries to transfer */ -int nr =min3 (from->avail, max, to->limit - to->avail); - -if (!nr) -return 0 ; - -memcpy (to->entry + to->avail, from->entry + from->avail - nr, -sizeof (void *) *nr); - - from->avail -= nr; - to->avail += nr; -return nr; -} - -/* &alien->lock must be held by alien callers. */ -static __always_inline void __free_one(struct array_cache *ac, void *objp) -{ -/* Avoid trivial double-free. */ -if (IS_ENABLED (CONFIG_SLAB_FREELIST_HARDENED ) && -WARN_ON_ONCE (ac->avail >0 && ac->entry[ac->avail -1 ] == objp)) -return ; - ac->entry[ac->avail++] = objp; -} - -#ifndef CONFIG_NUMA - -#define drain_alien_cache (cachep, alien) do { } while (0) -#define reap_alien (cachep, n) do { } while (0) - -static inline struct alien_cache **alloc_alien_cache (int node, -int limit,gfp_t gfp) -{ -return NULL ; -} - -static inline void free_alien_cache (struct alien_cache **ac_ptr) -{ -} - -static inline int cache_free_alien (struct kmem_cache *cachep,void *objp) -{ -return 0 ; -} - -static inline gfp_t gfp_exact_node (gfp_t flags) -{ -return flags & ~__GFP_NOFAIL; -} - -#else /* CONFIG_NUMA */ - -static struct alien_cache *__alloc_alien_cache (int node,int entries, -int batch,gfp_t gfp) -{ -size_t memsize =sizeof (void *) * entries +sizeof (struct alien_cache ); -struct alien_cache *alc =NULL ; - - alc =kmalloc_node (memsize, gfp, node); -if (alc) { -kmemleak_no_scan (alc); -init_arraycache (&alc->ac, entries, batch); -spin_lock_init (&alc->lock); - } -return alc; -} - -static struct alien_cache **alloc_alien_cache (int node,int limit,gfp_t gfp) -{ -struct alien_cache **alc_ptr; -int i; - -if (limit >1 ) - limit =12 ; - alc_ptr =kcalloc_node (nr_node_ids,sizeof (void *), gfp, node); -if (!alc_ptr) -return NULL ; - -for_each_node (i) { -if (i == node || !node_online (i)) -continue ; - alc_ptr[i] =__alloc_alien_cache (node, limit,0xbaadf00d , gfp); -if (!alc_ptr[i]) { -for (i--; i >=0 ; i--) -kfree (alc_ptr[i]); -kfree (alc_ptr); -return NULL ; - } - } -return alc_ptr; -} - -static void free_alien_cache (struct alien_cache **alc_ptr) -{ -int i; - -if (!alc_ptr) -return ; -for_each_node (i) -kfree (alc_ptr[i]); -kfree (alc_ptr); -} - -static void __drain_alien_cache (struct kmem_cache *cachep, -struct array_cache *ac,int node, -struct list_head *list) -{ -struct kmem_cache_node *n =get_node (cachep, node); - -if (ac->avail) { -raw_spin_lock (&n->list_lock); -/* -* Stuff objects into the remote nodes shared array first. -* That way we could avoid the overhead of putting the objects -* into the free lists and getting them back later. -*/ -if (n->shared) -transfer_objects (n->shared, ac, ac->limit); - -free_block (cachep, ac->entry, ac->avail, node, list); - ac->avail =0 ; -raw_spin_unlock (&n->list_lock); - } -} - -/* -* Called from cache_reap() to regularly drain alien caches round robin. -*/ -static void reap_alien (struct kmem_cache *cachep,struct kmem_cache_node *n) -{ -int node =__this_cpu_read (slab_reap_node); - -if (n->alien) { -struct alien_cache *alc = n->alien[node]; -struct array_cache *ac; - -if (alc) { - ac = &alc->ac; -if (ac->avail &&spin_trylock_irq (&alc->lock)) { -LIST_HEAD (list); - -__drain_alien_cache (cachep, ac, node, &list); -spin_unlock_irq (&alc->lock); -slabs_destroy (cachep, &list); - } - } - } -} - -static void drain_alien_cache (struct kmem_cache *cachep, -struct alien_cache **alien) -{ -int i =0 ; -struct alien_cache *alc; -struct array_cache *ac; -unsigned long flags; - -for_each_online_node (i) { - alc = alien[i]; -if (alc) { -LIST_HEAD (list); - - ac = &alc->ac; -spin_lock_irqsave (&alc->lock, flags); -__drain_alien_cache (cachep, ac, i, &list); -spin_unlock_irqrestore (&alc->lock, flags); -slabs_destroy (cachep, &list); - } - } -} - -static int __cache_free_alien (struct kmem_cache *cachep,void *objp, -int node,int slab_node) -{ -struct kmem_cache_node *n; -struct alien_cache *alien =NULL ; -struct array_cache *ac; -LIST_HEAD (list); - - n =get_node (cachep, node); -STATS_INC_NODEFREES (cachep); -if (n->alien && n->alien[slab_node]) { - alien = n->alien[slab_node]; - ac = &alien->ac; -spin_lock (&alien->lock); -if (unlikely (ac->avail == ac->limit)) { -STATS_INC_ACOVERFLOW (cachep); -__drain_alien_cache (cachep, ac, slab_node, &list); - } -__free_one (ac, objp); -spin_unlock (&alien->lock); -slabs_destroy (cachep, &list); - }else { - n =get_node (cachep, slab_node); -raw_spin_lock (&n->list_lock); -free_block (cachep, &objp,1 , slab_node, &list); -raw_spin_unlock (&n->list_lock); -slabs_destroy (cachep, &list); - } -return 1 ; -} - -static inline int cache_free_alien (struct kmem_cache *cachep,void *objp) -{ -int slab_node =slab_nid (virt_to_slab (objp)); -int node =numa_mem_id (); -/* -* Make sure we are not freeing an object from another node to the array -* cache on this cpu. -*/ -if (likely (node == slab_node)) -return 0 ; - -return __cache_free_alien (cachep, objp, node, slab_node); -} - -/* -* Construct gfp mask to allocate from a specific node but do not reclaim or -* warn about failures. -*/ -static inline gfp_t gfp_exact_node (gfp_t flags) -{ -return (flags | __GFP_THISNODE | __GFP_NOWARN) & ~(__GFP_RECLAIM|__GFP_NOFAIL); -} -#endif - -static int init_cache_node (struct kmem_cache *cachep,int node,gfp_t gfp) -{ -struct kmem_cache_node *n; - -/* -* Set up the kmem_cache_node for cpu before we can -* begin anything. Make sure some other cpu on this -* node has not already allocated this -*/ - n =get_node (cachep, node); -if (n) { -raw_spin_lock_irq (&n->list_lock); - n->free_limit = (1 +nr_cpus_node (node)) * cachep->batchcount + - cachep->num; -raw_spin_unlock_irq (&n->list_lock); - -return 0 ; - } - - n =kmalloc_node (sizeof (struct kmem_cache_node ), gfp, node); -if (!n) -return -ENOMEM ; - -kmem_cache_node_init (n); - n->next_reap = jiffies +REAPTIMEOUT_NODE + - ((unsigned long )cachep) %REAPTIMEOUT_NODE ; - - n->free_limit = - (1 +nr_cpus_node (node)) * cachep->batchcount + cachep->num; - -/* -* The kmem_cache_nodes don't come and go as CPUs -* come and go. slab_mutex provides sufficient -* protection here. -*/ - cachep->node[node] = n; - -return 0 ; -} - -#if defined(CONFIG_NUMA ) || defined(CONFIG_SMP ) -/* -* Allocates and initializes node for a node on each slab cache, used for -* either memory or cpu hotplug. If memory is being hot-added, the kmem_cache_node -* will be allocated off-node since memory is not yet online for the new node. -* When hotplugging memory or a cpu, existing nodes are not replaced if -* already in use. -* -* Must hold slab_mutex. -*/ -static int init_cache_node_node (int node) -{ -int ret; -struct kmem_cache *cachep; - -list_for_each_entry (cachep, &slab_caches, list) { - ret =init_cache_node (cachep, node,GFP_KERNEL ); -if (ret) -return ret; - } - -return 0 ; -} -#endif - -static int setup_kmem_cache_node (struct kmem_cache *cachep, -int node,gfp_t gfp,bool force_change) -{ -int ret = -ENOMEM ; -struct kmem_cache_node *n; -struct array_cache *old_shared =NULL ; -struct array_cache *new_shared =NULL ; -struct alien_cache **new_alien =NULL ; -LIST_HEAD (list); - -if (use_alien_caches) { - new_alien =alloc_alien_cache (node, cachep->limit, gfp); -if (!new_alien) - goto fail; - } - -if (cachep->shared) { - new_shared =alloc_arraycache (node, - cachep->shared * cachep->batchcount,0xbaadf00d , gfp); -if (!new_shared) - goto fail; - } - - ret =init_cache_node (cachep, node, gfp); -if (ret) - goto fail; - - n =get_node (cachep, node); -raw_spin_lock_irq (&n->list_lock); -if (n->shared && force_change) { -free_block (cachep, n->shared->entry, - n->shared->avail, node, &list); - n->shared->avail =0 ; - } - -if (!n->shared || force_change) { - old_shared = n->shared; - n->shared = new_shared; - new_shared =NULL ; - } - -if (!n->alien) { - n->alien = new_alien; - new_alien =NULL ; - } - -raw_spin_unlock_irq (&n->list_lock); -slabs_destroy (cachep, &list); - -/* -* To protect lockless access to n->shared during irq disabled context. -* If n->shared isn't NULL in irq disabled context, accessing to it is -* guaranteed to be valid until irq is re-enabled, because it will be -* freed after synchronize_rcu(). -*/ -if (old_shared && force_change) -synchronize_rcu (); - -fail: -kfree (old_shared); -kfree (new_shared); -free_alien_cache (new_alien); - -return ret; -} - -#ifdef CONFIG_SMP - -static void cpuup_canceled (long cpu) -{ -struct kmem_cache *cachep; -struct kmem_cache_node *n =NULL ; -int node =cpu_to_mem (cpu); -const struct cpumask *mask =cpumask_of_node (node); - -list_for_each_entry (cachep, &slab_caches, list) { -struct array_cache *nc; -struct array_cache *shared; -struct alien_cache **alien; -LIST_HEAD (list); - - n =get_node (cachep, node); -if (!n) -continue ; - -raw_spin_lock_irq (&n->list_lock); - -/* Free limit for this kmem_cache_node */ - n->free_limit -= cachep->batchcount; - -/* cpu is dead; no one can alloc from it. */ - nc =per_cpu_ptr (cachep->cpu_cache, cpu); -free_block (cachep, nc->entry, nc->avail, node, &list); - nc->avail =0 ; - -if (!cpumask_empty (mask)) { -raw_spin_unlock_irq (&n->list_lock); - goto free_slab; - } - - shared = n->shared; -if (shared) { -free_block (cachep, shared->entry, - shared->avail, node, &list); - n->shared =NULL ; - } - - alien = n->alien; - n->alien =NULL ; - -raw_spin_unlock_irq (&n->list_lock); - -kfree (shared); -if (alien) { -drain_alien_cache (cachep, alien); -free_alien_cache (alien); - } - -free_slab: -slabs_destroy (cachep, &list); - } -/* -* In the previous loop, all the objects were freed to -* the respective cache's slabs, now we can go ahead and -* shrink each nodelist to its limit. -*/ -list_for_each_entry (cachep, &slab_caches, list) { - n =get_node (cachep, node); -if (!n) -continue ; -drain_freelist (cachep, n,INT_MAX ); - } -} - -static int cpuup_prepare (long cpu) -{ -struct kmem_cache *cachep; -int node =cpu_to_mem (cpu); -int err; - -/* -* We need to do this right in the beginning since -* alloc_arraycache's are going to use this list. -* kmalloc_node allows us to add the slab to the right -* kmem_cache_node and not this cpu's kmem_cache_node -*/ - err =init_cache_node_node (node); -if (err <0 ) - goto bad; - -/* -* Now we can go ahead with allocating the shared arrays and -* array caches -*/ -list_for_each_entry (cachep, &slab_caches, list) { - err =setup_kmem_cache_node (cachep, node,GFP_KERNEL , false); -if (err) - goto bad; - } - -return 0 ; -bad: -cpuup_canceled (cpu); -return -ENOMEM ; -} - -int slab_prepare_cpu (unsigned int cpu) -{ -int err; - -mutex_lock (&slab_mutex); - err =cpuup_prepare (cpu); -mutex_unlock (&slab_mutex); -return err; -} - -/* -* This is called for a failed online attempt and for a successful -* offline. -* -* Even if all the cpus of a node are down, we don't free the -* kmem_cache_node of any cache. This is to avoid a race between cpu_down, and -* a kmalloc allocation from another cpu for memory from the node of -* the cpu going down. The kmem_cache_node structure is usually allocated from -* kmem_cache_create() and gets destroyed at kmem_cache_destroy(). -*/ -int slab_dead_cpu (unsigned int cpu) -{ -mutex_lock (&slab_mutex); -cpuup_canceled (cpu); -mutex_unlock (&slab_mutex); -return 0 ; -} -#endif - -static int slab_online_cpu (unsigned int cpu) -{ -start_cpu_timer (cpu); -return 0 ; -} - -static int slab_offline_cpu (unsigned int cpu) -{ -/* -* Shutdown cache reaper. Note that the slab_mutex is held so -* that if cache_reap() is invoked it cannot do anything -* expensive but will only modify reap_work and reschedule the -* timer. -*/ -cancel_delayed_work_sync (&per_cpu (slab_reap_work, cpu)); -/* Now the cache_reaper is guaranteed to be not running. */ -per_cpu (slab_reap_work, cpu).work.func =NULL ; -return 0 ; -} - -#if defined(CONFIG_NUMA ) -/* -* Drains freelist for a node on each slab cache, used for memory hot-remove. -* Returns -EBUSY if all objects cannot be drained so that the node is not -* removed. -* -* Must hold slab_mutex. -*/ -static int __meminit drain_cache_node_node (int node) -{ -struct kmem_cache *cachep; -int ret =0 ; - -list_for_each_entry (cachep, &slab_caches, list) { -struct kmem_cache_node *n; - - n =get_node (cachep, node); -if (!n) -continue ; - -drain_freelist (cachep, n,INT_MAX ); - -if (!list_empty (&n->slabs_full) || - !list_empty (&n->slabs_partial)) { - ret = -EBUSY ; -break ; - } - } -return ret; -} - -static int __meminit slab_memory_callback (struct notifier_block *self, -unsigned long action,void *arg) -{ -struct memory_notify *mnb = arg; -int ret =0 ; -int nid; - - nid = mnb->status_change_nid; -if (nid <0 ) - goto out; - -switch (action) { -case MEM_GOING_ONLINE : -mutex_lock (&slab_mutex); - ret =init_cache_node_node (nid); -mutex_unlock (&slab_mutex); -break ; -case MEM_GOING_OFFLINE : -mutex_lock (&slab_mutex); - ret =drain_cache_node_node (nid); -mutex_unlock (&slab_mutex); -break ; -case MEM_ONLINE : -case MEM_OFFLINE : -case MEM_CANCEL_ONLINE : -case MEM_CANCEL_OFFLINE : -break ; - } -out: -return notifier_from_errno (ret); -} -#endif /* CONFIG_NUMA */ - -/* -* swap the static kmem_cache_node with kmalloced memory -*/ -static void __init init_list (struct kmem_cache *cachep,struct kmem_cache_node *list, -int nodeid) -{ -struct kmem_cache_node *ptr; - - ptr =kmalloc_node (sizeof (struct kmem_cache_node ),GFP_NOWAIT , nodeid); -BUG_ON (!ptr); - -memcpy (ptr, list,sizeof (struct kmem_cache_node )); -/* -* Do not assume that spinlocks can be initialized via memcpy: -*/ -raw_spin_lock_init (&ptr->list_lock); - -MAKE_ALL_LISTS (cachep, ptr, nodeid); - cachep->node[nodeid] = ptr; -} - -/* -* For setting up all the kmem_cache_node for cache whose buffer_size is same as -* size of kmem_cache_node. -*/ -static void __init set_up_node (struct kmem_cache *cachep,int index) -{ -int node; - -for_each_online_node (node) { - cachep->node[node] = &init_kmem_cache_node[index + node]; - cachep->node[node]->next_reap = jiffies + -REAPTIMEOUT_NODE + - ((unsigned long )cachep) %REAPTIMEOUT_NODE ; - } -} - -/* -* Initialisation. Called after the page allocator have been initialised and -* before smp_init(). -*/ -void __init kmem_cache_init (void ) -{ -int i; - - kmem_cache = &kmem_cache_boot; - -if (!IS_ENABLED (CONFIG_NUMA ) ||num_possible_nodes () ==1 ) - use_alien_caches =0 ; - -for (i =0 ; i <NUM_INIT_LISTS ; i++) -kmem_cache_node_init (&init_kmem_cache_node[i]); - -/* -* Fragmentation resistance on low memory - only use bigger -* page orders on machines with more than 32MB of memory if -* not overridden on the command line. -*/ -if (!slab_max_order_set &&totalram_pages () > (32 <<20 ) >>PAGE_SHIFT ) - slab_max_order =SLAB_MAX_ORDER_HI ; - -/* Bootstrap is tricky, because several objects are allocated -* from caches that do not exist yet: -* 1) initialize the kmem_cache cache: it contains the struct -* kmem_cache structures of all caches, except kmem_cache itself: -* kmem_cache is statically allocated. -* Initially an __init data area is used for the head array and the -* kmem_cache_node structures, it's replaced with a kmalloc allocated -* array at the end of the bootstrap. -* 2) Create the first kmalloc cache. -* The struct kmem_cache for the new cache is allocated normally. -* An __init data area is used for the head array. -* 3) Create the remaining kmalloc caches, with minimally sized -* head arrays. -* 4) Replace the __init data head arrays for kmem_cache and the first -* kmalloc cache with kmalloc allocated arrays. -* 5) Replace the __init data for kmem_cache_node for kmem_cache and -* the other cache's with kmalloc allocated memory. -* 6) Resize the head arrays of the kmalloc caches to their final sizes. -*/ - -/* 1) create the kmem_cache */ - -/* -* struct kmem_cache size depends on nr_node_ids & nr_cpu_ids -*/ -create_boot_cache (kmem_cache,"kmem_cache" , - offsetof(struct kmem_cache , node) + - nr_node_ids *sizeof (struct kmem_cache_node *), -SLAB_HWCACHE_ALIGN ,0 ,0 ); -list_add (&kmem_cache->list, &slab_caches); - slab_state =PARTIAL ; - -/* -* Initialize the caches that provide memory for the kmem_cache_node -* structures first. Without this, further allocations will bug. -*/ - kmalloc_caches[KMALLOC_NORMAL ][INDEX_NODE ] =create_kmalloc_cache ( - kmalloc_info[INDEX_NODE ].name[KMALLOC_NORMAL ], - kmalloc_info[INDEX_NODE ].size, -ARCH_KMALLOC_FLAGS ,0 , - kmalloc_info[INDEX_NODE ].size); - slab_state =PARTIAL_NODE ; -setup_kmalloc_cache_index_table (); - -/* 5) Replace the bootstrap kmem_cache_node */ - { -int nid; - -for_each_online_node (nid) { -init_list (kmem_cache, &init_kmem_cache_node[CACHE_CACHE + nid], nid); - -init_list (kmalloc_caches[KMALLOC_NORMAL ][INDEX_NODE ], - &init_kmem_cache_node[SIZE_NODE + nid], nid); - } - } - -create_kmalloc_caches (ARCH_KMALLOC_FLAGS ); -} - -void __init kmem_cache_init_late (void ) -{ -struct kmem_cache *cachep; - -/* 6) resize the head arrays to their final sizes */ -mutex_lock (&slab_mutex); -list_for_each_entry (cachep, &slab_caches, list) -if (enable_cpucache (cachep,GFP_NOWAIT )) -BUG (); -mutex_unlock (&slab_mutex); - -/* Done! */ - slab_state =FULL ; - -#ifdef CONFIG_NUMA -/* -* Register a memory hotplug callback that initializes and frees -* node. -*/ -hotplug_memory_notifier (slab_memory_callback,SLAB_CALLBACK_PRI ); -#endif - -/* -* The reap timers are started later, with a module init call: That part -* of the kernel is not yet operational. -*/ -} - -static int __init cpucache_init (void ) -{ -int ret; - -/* -* Register the timers that return unneeded pages to the page allocator -*/ - ret =cpuhp_setup_state (CPUHP_AP_ONLINE_DYN ,"SLAB online" , - slab_online_cpu, slab_offline_cpu); -WARN_ON (ret <0 ); - -return 0 ; -} -__initcall (cpucache_init); - -static noinline void -slab_out_of_memory (struct kmem_cache *cachep,gfp_t gfpflags,int nodeid) -{ -#if DEBUG -struct kmem_cache_node *n; -unsigned long flags; -int node; - static DEFINE_RATELIMIT_STATE(slab_oom_rs, DEFAULT_RATELIMIT_INTERVAL, - DEFAULT_RATELIMIT_BURST); - -if ((gfpflags & __GFP_NOWARN) || !__ratelimit (&slab_oom_rs)) -return ; - -pr_warn ("SLAB: Unable to allocate memory on node %d, gfp=%#x(%pGg)\n" , - nodeid, gfpflags, &gfpflags); -pr_warn (" cache: %s, object size: %d, order: %d\n" , - cachep->name, cachep->size, cachep->gfporder); - -for_each_kmem_cache_node (cachep, node, n) { -unsigned long total_slabs, free_slabs, free_objs; - -raw_spin_lock_irqsave (&n->list_lock, flags); - total_slabs = n->total_slabs; - free_slabs = n->free_slabs; - free_objs = n->free_objects; -raw_spin_unlock_irqrestore (&n->list_lock, flags); - -pr_warn (" node %d: slabs: %ld/%ld, objs: %ld/%ld\n" , - node, total_slabs - free_slabs, total_slabs, - (total_slabs * cachep->num) - free_objs, - total_slabs * cachep->num); - } -#endif -} - -/* -* Interface to system's page allocator. No need to hold the -* kmem_cache_node ->list_lock. -* -* If we requested dmaable memory, we will get it. Even if we -* did not request dmaable memory, we might get it, but that -* would be relatively rare and ignorable. -*/ -static struct slab *kmem_getpages (struct kmem_cache *cachep,gfp_t flags, -int nodeid) -{ -struct folio *folio; -struct slab *slab; - - flags |= cachep->allocflags; - - folio = (struct folio *)__alloc_pages_node (nodeid, flags, cachep->gfporder); -if (!folio) { -slab_out_of_memory (cachep, flags, nodeid); -return NULL ; - } - - slab =folio_slab (folio); - -account_slab (slab, cachep->gfporder, cachep, flags); -__folio_set_slab (folio); -/* Make the flag visible before any changes to folio->mapping */ -smp_wmb (); -/* Record if ALLOC_NO_WATERMARKS was set when allocating the slab */ -if (sk_memalloc_socks () &&folio_is_pfmemalloc (folio)) -slab_set_pfmemalloc (slab); - -return slab; -} - -/* -* Interface to system's page release. -*/ -static void kmem_freepages (struct kmem_cache *cachep,struct slab *slab) -{ -int order = cachep->gfporder; -struct folio *folio =slab_folio (slab); - -BUG_ON (!folio_test_slab (folio)); -__slab_clear_pfmemalloc (slab); -page_mapcount_reset (&folio->page); - folio->mapping =NULL ; -/* Make the mapping reset visible before clearing the flag */ -smp_wmb (); -__folio_clear_slab (folio); - -if (current->reclaim_state) - current->reclaim_state->reclaimed_slab +=1 << order; -unaccount_slab (slab, order, cachep); -__free_pages (&folio->page, order); -} - -static void kmem_rcu_free (struct rcu_head *head) -{ -struct kmem_cache *cachep; -struct slab *slab; - - slab = container_of(head, struct slab, rcu_head); - cachep = slab->slab_cache; - -kmem_freepages (cachep, slab); -} - -#if DEBUG -static inline bool is_debug_pagealloc_cache (struct kmem_cache *cachep) -{ -return debug_pagealloc_enabled_static () &&OFF_SLAB (cachep) && - ((cachep->size %PAGE_SIZE ) ==0 ); -} - -#ifdef CONFIG_DEBUG_PAGEALLOC -static void slab_kernel_map (struct kmem_cache *cachep,void *objp,int map) -{ -if (!is_debug_pagealloc_cache (cachep)) -return ; - -__kernel_map_pages (virt_to_page (objp), cachep->size /PAGE_SIZE , map); -} - -#else -static inline void slab_kernel_map (struct kmem_cache *cachep,void *objp, -int map) {} - -#endif - -static void poison_obj (struct kmem_cache *cachep,void *addr,unsigned char val) -{ -int size = cachep->object_size; - addr = &((char *)addr)[obj_offset (cachep)]; - -memset (addr, val, size); - *(unsigned char *)(addr + size -1 ) =POISON_END ; -} - -static void dump_line (char *data,int offset,int limit) -{ -int i; -unsigned char error =0 ; -int bad_count =0 ; - -pr_err ("%03x: " , offset); -for (i =0 ; i < limit; i++) { -if (data[offset + i] !=POISON_FREE ) { - error = data[offset + i]; - bad_count++; - } - } -print_hex_dump (KERN_CONT ,"" ,0 ,16 ,1 , - &data[offset], limit,1 ); - -if (bad_count ==1 ) { - error ^=POISON_FREE ; -if (!(error & (error -1 ))) { -pr_err ("Single bit error detected. Probably bad RAM.\n" ); -#ifdef CONFIG_X86 -pr_err ("Run memtest86+ or a similar memory test tool.\n" ); -#else -pr_err ("Run a memory test tool.\n" ); -#endif - } - } -} -#endif - -#if DEBUG - -static void print_objinfo (struct kmem_cache *cachep,void *objp,int lines) -{ -int i, size; -char *realobj; - -if (cachep->flags &SLAB_RED_ZONE ) { -pr_err ("Redzone: 0x%llx/0x%llx\n" , - *dbg_redzone1 (cachep, objp), - *dbg_redzone2 (cachep, objp)); - } - -if (cachep->flags &SLAB_STORE_USER ) -pr_err ("Last user: (%pSR)\n" , *dbg_userword (cachep, objp)); - realobj = (char *)objp +obj_offset (cachep); - size = cachep->object_size; -for (i =0 ; i < size && lines; i +=16 , lines--) { -int limit; - limit =16 ; -if (i + limit > size) - limit = size - i; -dump_line (realobj, i, limit); - } -} - -static void check_poison_obj (struct kmem_cache *cachep,void *objp) -{ -char *realobj; -int size, i; -int lines =0 ; - -if (is_debug_pagealloc_cache (cachep)) -return ; - - realobj = (char *)objp +obj_offset (cachep); - size = cachep->object_size; - -for (i =0 ; i < size; i++) { -char exp =POISON_FREE ; -if (i == size -1 ) - exp =POISON_END ; -if (realobj[i] != exp) { -int limit; -/* Mismatch ! */ -/* Print header */ -if (lines ==0 ) { -pr_err ("Slab corruption (%s): %s start=%px, len=%d\n" , -print_tainted (), cachep->name, - realobj, size); -print_objinfo (cachep, objp,0 ); - } -/* Hexdump the affected line */ - i = (i /16 ) *16 ; - limit =16 ; -if (i + limit > size) - limit = size - i; -dump_line (realobj, i, limit); - i +=16 ; - lines++; -/* Limit to 5 lines */ -if (lines >5 ) -break ; - } - } -if (lines !=0 ) { -/* Print some data about the neighboring objects, if they -* exist: -*/ -struct slab *slab =virt_to_slab (objp); -unsigned int objnr; - - objnr =obj_to_index (cachep, slab, objp); -if (objnr) { - objp =index_to_obj (cachep, slab, objnr -1 ); - realobj = (char *)objp +obj_offset (cachep); -pr_err ("Prev obj: start=%px, len=%d\n" , realobj, size); -print_objinfo (cachep, objp,2 ); - } -if (objnr +1 < cachep->num) { - objp =index_to_obj (cachep, slab, objnr +1 ); - realobj = (char *)objp +obj_offset (cachep); -pr_err ("Next obj: start=%px, len=%d\n" , realobj, size); -print_objinfo (cachep, objp,2 ); - } - } -} -#endif - -#if DEBUG -static void slab_destroy_debugcheck (struct kmem_cache *cachep, -struct slab *slab) -{ -int i; - -if (OBJFREELIST_SLAB (cachep) && cachep->flags &SLAB_POISON ) { -poison_obj (cachep, slab->freelist -obj_offset (cachep), -POISON_FREE ); - } - -for (i =0 ; i < cachep->num; i++) { -void *objp =index_to_obj (cachep, slab, i); - -if (cachep->flags &SLAB_POISON ) { -check_poison_obj (cachep, objp); -slab_kernel_map (cachep, objp,1 ); - } -if (cachep->flags &SLAB_RED_ZONE ) { -if (*dbg_redzone1 (cachep, objp) !=RED_INACTIVE ) -slab_error (cachep,"start of a freed object was overwritten" ); -if (*dbg_redzone2 (cachep, objp) !=RED_INACTIVE ) -slab_error (cachep,"end of a freed object was overwritten" ); - } - } -} -#else -static void slab_destroy_debugcheck (struct kmem_cache *cachep, -struct slab *slab) -{ -} -#endif - -/** -* slab_destroy - destroy and release all objects in a slab -* @cachep: cache pointer being destroyed -* @slab: slab being destroyed -* -* Destroy all the objs in a slab, and release the mem back to the system. -* Before calling the slab must have been unlinked from the cache. The -* kmem_cache_node ->list_lock is not held/needed. -*/ -static void slab_destroy (struct kmem_cache *cachep,struct slab *slab) -{ -void *freelist; - - freelist = slab->freelist; -slab_destroy_debugcheck (cachep, slab); -if (unlikely (cachep->flags &SLAB_TYPESAFE_BY_RCU )) -call_rcu (&slab->rcu_head, kmem_rcu_free); -else -kmem_freepages (cachep, slab); - -/* -* From now on, we don't use freelist -* although actual page can be freed in rcu context -*/ -if (OFF_SLAB (cachep)) -kfree (freelist); -} - -/* -* Update the size of the caches before calling slabs_destroy as it may -* recursively call kfree. -*/ -static void slabs_destroy (struct kmem_cache *cachep,struct list_head *list) -{ -struct slab *slab, *n; - -list_for_each_entry_safe (slab, n, list, slab_list) { -list_del (&slab->slab_list); -slab_destroy (cachep, slab); - } -} - -/** -* calculate_slab_order - calculate size (page order) of slabs -* @cachep: pointer to the cache that is being created -* @size: size of objects to be created in this cache. -* @flags: slab allocation flags -* -* Also calculates the number of objects per slab. -* -* This could be made much more intelligent. For now, try to avoid using -* high order pages for slabs. When the gfp() functions are more friendly -* towards high-order requests, this should be changed. -* -* Return: number of left-over bytes in a slab -*/ -static size_t calculate_slab_order (struct kmem_cache *cachep, -size_t size,slab_flags_t flags) -{ -size_t left_over =0 ; -int gfporder; - -for (gfporder =0 ; gfporder <=KMALLOC_MAX_ORDER ; gfporder++) { -unsigned int num; -size_t remainder; - - num =cache_estimate (gfporder, size, flags, &remainder); -if (!num) -continue ; - -/* Can't handle number of objects more than SLAB_OBJ_MAX_NUM */ -if (num >SLAB_OBJ_MAX_NUM ) -break ; - -if (flags &CFLGS_OFF_SLAB ) { -struct kmem_cache *freelist_cache; -size_t freelist_size; -size_t freelist_cache_size; - - freelist_size = num *sizeof (freelist_idx_t); -if (freelist_size >KMALLOC_MAX_CACHE_SIZE ) { - freelist_cache_size =PAGE_SIZE <<get_order (freelist_size); - }else { - freelist_cache =kmalloc_slab (freelist_size,0u ); -if (!freelist_cache) -continue ; - freelist_cache_size = freelist_cache->size; - -/* -* Needed to avoid possible looping condition -* in cache_grow_begin() -*/ -if (OFF_SLAB (freelist_cache)) -continue ; - } - -/* check if off slab has enough benefit */ -if (freelist_cache_size > cachep->size /2 ) -continue ; - } - -/* Found something acceptable - save it away */ - cachep->num = num; - cachep->gfporder = gfporder; - left_over = remainder; - -/* -* A VFS-reclaimable slab tends to have most allocations -* as GFP_NOFS and we really don't want to have to be allocating -* higher-order pages when we are unable to shrink dcache. -*/ -if (flags &SLAB_RECLAIM_ACCOUNT ) -break ; - -/* -* Large number of objects is good, but very large slabs are -* currently bad for the gfp()s. -*/ -if (gfporder >= slab_max_order) -break ; - -/* -* Acceptable internal fragmentation? -*/ -if (left_over *8 <= (PAGE_SIZE << gfporder)) -break ; - } -return left_over; -} - -static struct array_cache __percpu *alloc_kmem_cache_cpus ( -struct kmem_cache *cachep,int entries,int batchcount) -{ -int cpu; -size_t size; -struct array_cache __percpu *cpu_cache; - - size =sizeof (void *) * entries +sizeof (struct array_cache ); - cpu_cache =__alloc_percpu (size,sizeof (void *)); - -if (!cpu_cache) -return NULL ; - -for_each_possible_cpu (cpu) { -init_arraycache (per_cpu_ptr (cpu_cache, cpu), - entries, batchcount); - } - -return cpu_cache; -} - -static int __ref setup_cpu_cache (struct kmem_cache *cachep,gfp_t gfp) -{ -if (slab_state >=FULL ) -return enable_cpucache (cachep, gfp); - - cachep->cpu_cache =alloc_kmem_cache_cpus (cachep,1 ,1 ); -if (!cachep->cpu_cache) -return 1 ; - -if (slab_state ==DOWN ) { -/* Creation of first cache (kmem_cache). */ -set_up_node (kmem_cache,CACHE_CACHE ); - }else if (slab_state ==PARTIAL ) { -/* For kmem_cache_node */ -set_up_node (cachep,SIZE_NODE ); - }else { -int node; - -for_each_online_node (node) { - cachep->node[node] =kmalloc_node ( -sizeof (struct kmem_cache_node ), gfp, node); -BUG_ON (!cachep->node[node]); -kmem_cache_node_init (cachep->node[node]); - } - } - - cachep->node[numa_mem_id ()]->next_reap = - jiffies +REAPTIMEOUT_NODE + - ((unsigned long )cachep) %REAPTIMEOUT_NODE ; - -cpu_cache_get (cachep)->avail =0 ; -cpu_cache_get (cachep)->limit =BOOT_CPUCACHE_ENTRIES ; -cpu_cache_get (cachep)->batchcount =1 ; -cpu_cache_get (cachep)->touched =0 ; - cachep->batchcount =1 ; - cachep->limit =BOOT_CPUCACHE_ENTRIES ; -return 0 ; -} - -slab_flags_t kmem_cache_flags (unsigned int object_size, -slab_flags_t flags,const char *name) -{ -return flags; -} - -struct kmem_cache * -__kmem_cache_alias (const char *name,unsigned int size,unsigned int align, -slab_flags_t flags,void (*ctor)(void *)) -{ -struct kmem_cache *cachep; - - cachep =find_mergeable (size, align, flags, name, ctor); -if (cachep) { - cachep->refcount++; - -/* -* Adjust the object sizes so that we clear -* the complete object on kzalloc. -*/ - cachep->object_size =max_t (int, cachep->object_size, size); - } -return cachep; -} - -static bool set_objfreelist_slab_cache (struct kmem_cache *cachep, -size_t size,slab_flags_t flags) -{ -size_t left; - - cachep->num =0 ; - -/* -* If slab auto-initialization on free is enabled, store the freelist -* off-slab, so that its contents don't end up in one of the allocated -* objects. -*/ -if (unlikely (slab_want_init_on_free (cachep))) -return false; - -if (cachep->ctor || flags &SLAB_TYPESAFE_BY_RCU ) -return false; - - left =calculate_slab_order (cachep, size, - flags |CFLGS_OBJFREELIST_SLAB ); -if (!cachep->num) -return false; - -if (cachep->num *sizeof (freelist_idx_t) > cachep->object_size) -return false; - - cachep->colour = left / cachep->colour_off; - -return true; -} - -static bool set_off_slab_cache (struct kmem_cache *cachep, -size_t size,slab_flags_t flags) -{ -size_t left; - - cachep->num =0 ; - -/* -* Always use on-slab management when SLAB_NOLEAKTRACE -* to avoid recursive calls into kmemleak. -*/ -if (flags &SLAB_NOLEAKTRACE ) -return false; - -/* -* Size is large, assume best to place the slab management obj -* off-slab (should allow better packing of objs). -*/ - left =calculate_slab_order (cachep, size, flags |CFLGS_OFF_SLAB ); -if (!cachep->num) -return false; - -/* -* If the slab has been placed off-slab, and we have enough space then -* move it on-slab. This is at the expense of any extra colouring. -*/ -if (left >= cachep->num *sizeof (freelist_idx_t)) -return false; - - cachep->colour = left / cachep->colour_off; - -return true; -} - -static bool set_on_slab_cache (struct kmem_cache *cachep, -size_t size,slab_flags_t flags) -{ -size_t left; - - cachep->num =0 ; - - left =calculate_slab_order (cachep, size, flags); -if (!cachep->num) -return false; - - cachep->colour = left / cachep->colour_off; - -return true; -} - -/** -* __kmem_cache_create - Create a cache. -* @cachep: cache management descriptor -* @flags: SLAB flags -* -* Returns a ptr to the cache on success, NULL on failure. -* Cannot be called within an int, but can be interrupted. -* The @ctor is run when new pages are allocated by the cache. -* -* The flags are -* -* %SLAB_POISON - Poison the slab with a known test pattern (a5a5a5a5) -* to catch references to uninitialised memory. -* -* %SLAB_RED_ZONE - Insert `Red' zones around the allocated memory to check -* for buffer overruns. -* -* %SLAB_HWCACHE_ALIGN - Align the objects in this cache to a hardware -* cacheline. This can be beneficial if you're counting cycles as closely -* as davem. -* -* Return: a pointer to the created cache or %NULL in case of error -*/ -int __kmem_cache_create (struct kmem_cache *cachep,slab_flags_t flags) -{ -size_t ralign =BYTES_PER_WORD ; -gfp_t gfp; -int err; -unsigned int size = cachep->size; - -#if DEBUG -#if FORCED_DEBUG -/* -* Enable redzoning and last user accounting, except for caches with -* large objects, if the increased size would increase the object size -* above the next power of two: caches with object sizes just above a -* power of two have a significant amount of internal fragmentation. -*/ -if (size <4096 ||fls (size -1 ) ==fls (size-1 +REDZONE_ALIGN + -2 *sizeof (unsigned long long ))) - flags |=SLAB_RED_ZONE |SLAB_STORE_USER ; -if (!(flags &SLAB_TYPESAFE_BY_RCU )) - flags |=SLAB_POISON ; -#endif -#endif - -/* -* Check that size is in terms of words. This is needed to avoid -* unaligned accesses for some archs when redzoning is used, and makes -* sure any on-slab bufctl's are also correctly aligned. -*/ - size =ALIGN (size,BYTES_PER_WORD ); - -if (flags &SLAB_RED_ZONE ) { - ralign =REDZONE_ALIGN ; -/* If redzoning, ensure that the second redzone is suitably -* aligned, by adjusting the object size accordingly. */ - size =ALIGN (size,REDZONE_ALIGN ); - } - -/* 3) caller mandated alignment */ -if (ralign < cachep->align) { - ralign = cachep->align; - } -/* disable debug if necessary */ -if (ralign > __alignof__(unsigned long long )) - flags &= ~(SLAB_RED_ZONE |SLAB_STORE_USER ); -/* -* 4) Store it. -*/ - cachep->align = ralign; - cachep->colour_off =cache_line_size (); -/* Offset must be a multiple of the alignment. */ -if (cachep->colour_off < cachep->align) - cachep->colour_off = cachep->align; - -if (slab_is_available ()) - gfp =GFP_KERNEL ; -else - gfp =GFP_NOWAIT ; - -#if DEBUG - -/* -* Both debugging options require word-alignment which is calculated -* into align above. -*/ -if (flags &SLAB_RED_ZONE ) { -/* add space for red zone words */ - cachep->obj_offset +=sizeof (unsigned long long ); - size +=2 *sizeof (unsigned long long ); - } -if (flags &SLAB_STORE_USER ) { -/* user store requires one word storage behind the end of -* the real object. But if the second red zone needs to be -* aligned to 64 bits, we must allow that much space. -*/ -if (flags &SLAB_RED_ZONE ) - size +=REDZONE_ALIGN ; -else - size +=BYTES_PER_WORD ; - } -#endif - -kasan_cache_create (cachep, &size, &flags); - - size =ALIGN (size, cachep->align); -/* -* We should restrict the number of objects in a slab to implement -* byte sized index. Refer comment on SLAB_OBJ_MIN_SIZE definition. -*/ -if (FREELIST_BYTE_INDEX && size <SLAB_OBJ_MIN_SIZE ) - size =ALIGN (SLAB_OBJ_MIN_SIZE , cachep->align); - -#if DEBUG -/* -* To activate debug pagealloc, off-slab management is necessary -* requirement. In early phase of initialization, small sized slab -* doesn't get initialized so it would not be possible. So, we need -* to check size >= 256. It guarantees that all necessary small -* sized slab is initialized in current slab initialization sequence. -*/ -if (debug_pagealloc_enabled_static () && (flags &SLAB_POISON ) && - size >=256 && cachep->object_size >cache_line_size ()) { -if (size <PAGE_SIZE || size %PAGE_SIZE ==0 ) { -size_t tmp_size =ALIGN (size,PAGE_SIZE ); - -if (set_off_slab_cache (cachep, tmp_size, flags)) { - flags |=CFLGS_OFF_SLAB ; - cachep->obj_offset += tmp_size - size; - size = tmp_size; - goto done; - } - } - } -#endif - -if (set_objfreelist_slab_cache (cachep, size, flags)) { - flags |=CFLGS_OBJFREELIST_SLAB ; - goto done; - } - -if (set_off_slab_cache (cachep, size, flags)) { - flags |=CFLGS_OFF_SLAB ; - goto done; - } - -if (set_on_slab_cache (cachep, size, flags)) - goto done; - -return -E2BIG ; - -done: - cachep->freelist_size = cachep->num *sizeof (freelist_idx_t); - cachep->flags = flags; - cachep->allocflags = __GFP_COMP; -if (flags &SLAB_CACHE_DMA ) - cachep->allocflags |=GFP_DMA ; -if (flags &SLAB_CACHE_DMA32 ) - cachep->allocflags |=GFP_DMA32 ; -if (flags &SLAB_RECLAIM_ACCOUNT ) - cachep->allocflags |= __GFP_RECLAIMABLE; - cachep->size = size; - cachep->reciprocal_buffer_size =reciprocal_value (size); - -#if DEBUG -/* -* If we're going to use the generic kernel_map_pages() -* poisoning, then it's going to smash the contents of -* the redzone and userword anyhow, so switch them off. -*/ -if (IS_ENABLED (CONFIG_PAGE_POISONING ) && - (cachep->flags &SLAB_POISON ) && -is_debug_pagealloc_cache (cachep)) - cachep->flags &= ~(SLAB_RED_ZONE |SLAB_STORE_USER ); -#endif - - err =setup_cpu_cache (cachep, gfp); -if (err) { -__kmem_cache_release (cachep); -return err; - } - -return 0 ; -} - -#if DEBUG -static void check_irq_off (void ) -{ -BUG_ON (!irqs_disabled ()); -} - -static void check_irq_on (void ) -{ -BUG_ON (irqs_disabled ()); -} - -static void check_mutex_acquired (void ) -{ -BUG_ON (!mutex_is_locked (&slab_mutex)); -} - -static void check_spinlock_acquired (struct kmem_cache *cachep) -{ -#ifdef CONFIG_SMP -check_irq_off (); -assert_raw_spin_locked (&get_node (cachep,numa_mem_id ())->list_lock); -#endif -} - -static void check_spinlock_acquired_node (struct kmem_cache *cachep,int node) -{ -#ifdef CONFIG_SMP -check_irq_off (); -assert_raw_spin_locked (&get_node (cachep, node)->list_lock); -#endif -} - -#else -#define check_irq_off () do { } while(0) -#define check_irq_on () do { } while(0) -#define check_mutex_acquired () do { } while(0) -#define check_spinlock_acquired (x) do { } while(0) -#define check_spinlock_acquired_node (x, y) do { } while(0) -#endif - -static void drain_array_locked (struct kmem_cache *cachep,struct array_cache *ac, -int node,bool free_all,struct list_head *list) -{ -int tofree; - -if (!ac || !ac->avail) -return ; - - tofree = free_all ? ac->avail : (ac->limit +4 ) /5 ; -if (tofree > ac->avail) - tofree = (ac->avail +1 ) /2 ; - -free_block (cachep, ac->entry, tofree, node, list); - ac->avail -= tofree; -memmove (ac->entry, &(ac->entry[tofree]),sizeof (void *) * ac->avail); -} - -static void do_drain (void *arg) -{ -struct kmem_cache *cachep = arg; -struct array_cache *ac; -int node =numa_mem_id (); -struct kmem_cache_node *n; -LIST_HEAD (list); - -check_irq_off (); - ac =cpu_cache_get (cachep); - n =get_node (cachep, node); -raw_spin_lock (&n->list_lock); -free_block (cachep, ac->entry, ac->avail, node, &list); -raw_spin_unlock (&n->list_lock); - ac->avail =0 ; -slabs_destroy (cachep, &list); -} - -static void drain_cpu_caches (struct kmem_cache *cachep) -{ -struct kmem_cache_node *n; -int node; -LIST_HEAD (list); - -on_each_cpu (do_drain, cachep,1 ); -check_irq_on (); -for_each_kmem_cache_node (cachep, node, n) -if (n->alien) -drain_alien_cache (cachep, n->alien); - -for_each_kmem_cache_node (cachep, node, n) { -raw_spin_lock_irq (&n->list_lock); -drain_array_locked (cachep, n->shared, node, true, &list); -raw_spin_unlock_irq (&n->list_lock); - -slabs_destroy (cachep, &list); - } -} - -/* -* Remove slabs from the list of free slabs. -* Specify the number of slabs to drain in tofree. -* -* Returns the actual number of slabs released. -*/ -static int drain_freelist (struct kmem_cache *cache, -struct kmem_cache_node *n,int tofree) -{ -struct list_head *p; -int nr_freed; -struct slab *slab; - - nr_freed =0 ; -while (nr_freed < tofree && !list_empty (&n->slabs_free)) { - -raw_spin_lock_irq (&n->list_lock); - p = n->slabs_free.prev; -if (p == &n->slabs_free) { -raw_spin_unlock_irq (&n->list_lock); - goto out; - } - - slab = list_entry(p, struct slab, slab_list); -list_del (&slab->slab_list); - n->free_slabs--; - n->total_slabs--; -/* -* Safe to drop the lock. The slab is no longer linked -* to the cache. -*/ - n->free_objects -= cache->num; -raw_spin_unlock_irq (&n->list_lock); -slab_destroy (cache, slab); - nr_freed++;Lines of this file are not shown. View the raw message.
The rest of this diff is not shown. View the raw message.
Quoted 2 lines
2.40.0
This is such a trivial fixup that it barely even requires review (I imagine Andrew will just take it as-is) but for the sake of being pedantic:-
Part of the diff is not shown here. View the raw message.
Quoted 40 lines · Vlastimil Babka
As the SLOB removal is on track and the SLAB removal is planned, I have realized - why should we stop there and not remove also SLUB? What's a slab allocator good for in 2023? The RAM sizes are getting larger and the modules cheaper [1]. The object constructor trick was perhaps interesting in 1994, but not with contemporary CPUs. So all the slab allocator does today is just adding an unnecessary layer of complexity over the page allocator.
Thus, with this patch, all three slab allocators are removed, and only a layer that passes everything to the page allocator remains in the
slab.handmm/slab_common.cfiles. This will allow users to gradually transition away and use the page allocator directly. To summarize the advantages:- Less code to maintain: over 13k lines are removed by this patch, and more could be removed if I wast^Wspent more time on this, and later as users are transitioned from the legacy layer. This no longer needs a separate subsystem so remove it from
MAINTAINERS(I hope I can keep the kernel.org account anyway, though).- Simplified
MEMCG_KMEMaccounting: while I was lazy and just marked it BROKEN in this patch, it should be trivial to use the page memcg accounting now that we use the page allocator. The per-object accounting went through several iterations in the past and was always complex and added overhead. Page accounting is much simpler by comparison.- Simplified KASAN and friends: also was lazy in this patch so they can't be enabled but should be easy to fix up and work just on the page level.
- Simpler debugging: just use debug_pagealloc=on, no need to look up the exact syntax of the absurdly complex
slub_debugparameter.- Speed: didn't measure, but for the page allocator we have pcplists, so it should scale just fine. No need for the crazy SLUB's
cmpxchg_double()craziness. Maybe that thing could be now removed too? Yeah I can see just two remaining users.
Quoted 7 lines
Any downsides? Let's look at memory usage after virtme boot:
Before (with SLUB):
Slab: 26304 kBAfter:
Slab: 295592 kB
Good catch. Easy 10x win in memory footprint.
Quoted 13,731 lines
Well, that's not so bad, see [1].
[1] https://www.theregister.com/2023/03/29/dram_prices_crash/
--- MAINTAINERS | 15 - include/linux/slab.h | 211 +- include/linux/slab_def.h | 124 - include/linux/slub_def.h | 198 -- init/Kconfig | 2 +- mm/Kconfig | 134 +- mm/Makefile | 10 - mm/slab.c | 4046 ------------------------ mm/slab.h | 426 --- mm/slab_common.c | 876 ++--- mm/slob.c | 757 ----- mm/slub.c | 6506 -------------------------------------- 12 files changed, 228 insertions(+), 13077 deletions(-) delete mode 100644 include/linux/slab_def.h delete mode 100644 include/linux/slub_def.h delete mode 100644 mm/slab.c delete mode 100644 mm/slob.c delete mode 100644 mm/slub.cMAINTAINERS +0
-15@@ -19183,21 +19183,6 @@ F: drivers/irqchip/irq-sl28cpld.c F: drivers/pwm/pwm-sl28cpld.c F: drivers/watchdog/sl28cpld_wdt.c -SLAB ALLOCATOR -M: Christoph Lameter <[email protected]> -M: Pekka Enberg <[email protected]> -M: David Rientjes <[email protected]> -M: Joonsoo Kim <[email protected]> -M: Andrew Morton <[email protected]> -M: Vlastimil Babka <[email protected]> -R: Roman Gushchin <[email protected]> -R: Hyeonggon Yoo <[email protected]> -L: [email protected] -S: Maintained -T: git git://git.kernel.org/pub/scm/linux/kernel/git/vbabka/slab.git -F: include/linux/sl?b*.h -F: mm/sl?b* - SLCAN CAN NETWORK DRIVER M: Dario Binacchi <[email protected]> L: [email protected]include/linux/slab.h +7
-204@@ -140,13 +140,14 @@/* The following flags affect the page allocator grouping pages by mobility */ /* Objects are reclaimable */ -#ifndef CONFIG_SLUB_TINY #define SLAB_RECLAIM_ACCOUNT ((slab_flags_t __force)0x00020000U) -#else -#define SLAB_RECLAIM_ACCOUNT ((slab_flags_t __force)0) -#endif #define SLAB_TEMPORARY SLAB_RECLAIM_ACCOUNT/* Objects are short-lived */ +#define KMALLOC_NOT_NORMAL_BITS \ + (__GFP_RECLAIMABLE | \ + (IS_ENABLED(CONFIG_ZONE_DMA) ? __GFP_DMA : 0) | \ + (IS_ENABLED(CONFIG_MEMCG_KMEM) ? __GFP_ACCOUNT : 0)) +/* * ZERO_SIZE_PTR will be returned for zero sized kmalloc requests. * @@ -278,38 +279,11 @@ static inline unsigned int arch_slab_minalign(void)* Kmalloc array related definitions */ -#ifdef CONFIG_SLAB -/* -* SLAB and SLUB directly allocates requests fitting in to an order-1 page -* (PAGE_SIZE*2). Larger requests are passed to the page allocator. -*/ -#define KMALLOC_SHIFT_HIGH (PAGE_SHIFT + 1) -#define KMALLOC_SHIFT_MAX (MAX_ORDER + PAGE_SHIFT - 1) -#ifndef KMALLOC_SHIFT_LOW -#define KMALLOC_SHIFT_LOW 5 -#endif -#endif - -#ifdef CONFIG_SLUB -#define KMALLOC_SHIFT_HIGH (PAGE_SHIFT + 1) -#define KMALLOC_SHIFT_MAX (MAX_ORDER + PAGE_SHIFT - 1) -#ifndef KMALLOC_SHIFT_LOW -#define KMALLOC_SHIFT_LOW 3 -#endif -#endif - -#ifdef CONFIG_SLOB -/* -* SLOB passes all requests larger than one page to the page allocator. -* No kmalloc array is necessary since objects of different sizes can -* be allocated from the same page. -*/ #define KMALLOC_SHIFT_HIGH PAGE_SHIFT#define KMALLOC_SHIFT_MAX (MAX_ORDER + PAGE_SHIFT - 1)#ifndef KMALLOC_SHIFT_LOW #define KMALLOC_SHIFT_LOW 3#endif -#endif /* Maximum allocatable size */ #define KMALLOC_MAX_SIZE (1UL << KMALLOC_SHIFT_MAX)@@ -336,130 +310,6 @@ static inline unsigned int arch_slab_minalign(void)#define SLAB_OBJ_MIN_SIZE (KMALLOC_MIN_SIZE < 16 ? \ (KMALLOC_MIN_SIZE) : 16) -/* -* Whenever changing this, take care of that kmalloc_type() and -* create_kmalloc_caches() still work as intended. -* -* KMALLOC_NORMAL can contain only unaccounted objects whereas KMALLOC_CGROUP -* is for accounted but unreclaimable and non-dma objects. All the other -* kmem caches can have both accounted and unaccounted objects. -*/ -enum kmalloc_cache_type { -KMALLOC_NORMAL =0 , -#ifndef CONFIG_ZONE_DMA -KMALLOC_DMA =KMALLOC_NORMAL , -#endif -#ifndef CONFIG_MEMCG_KMEM -KMALLOC_CGROUP =KMALLOC_NORMAL , -#endif -#ifdef CONFIG_SLUB_TINY -KMALLOC_RECLAIM =KMALLOC_NORMAL , -#else -KMALLOC_RECLAIM , -#endif -#ifdef CONFIG_ZONE_DMA -KMALLOC_DMA , -#endif -#ifdef CONFIG_MEMCG_KMEM -KMALLOC_CGROUP , -#endif -NR_KMALLOC_TYPES -}; - -#ifndef CONFIG_SLOB -extern struct kmem_cache * -kmalloc_caches[NR_KMALLOC_TYPES ][KMALLOC_SHIFT_HIGH +1 ]; - -/* -* Define gfp bits that should not be set for KMALLOC_NORMAL. -*/ -#define KMALLOC_NOT_NORMAL_BITS \ - (__GFP_RECLAIMABLE | \ - (IS_ENABLED(CONFIG_ZONE_DMA) ? __GFP_DMA : 0) | \ - (IS_ENABLED(CONFIG_MEMCG_KMEM) ? __GFP_ACCOUNT : 0)) - -static __always_inline enum kmalloc_cache_type kmalloc_type(gfp_t flags) -{ -/* -* The most common case is KMALLOC_NORMAL, so test for it -* with a single branch for all the relevant flags. -*/ -if (likely ((flags &KMALLOC_NOT_NORMAL_BITS ) ==0 )) -return KMALLOC_NORMAL ; - -/* -* At least one of the flags has to be set. Their priorities in -* decreasing order are: -* 1) __GFP_DMA -* 2) __GFP_RECLAIMABLE -* 3) __GFP_ACCOUNT -*/ -if (IS_ENABLED (CONFIG_ZONE_DMA ) && (flags & __GFP_DMA)) -return KMALLOC_DMA ; -if (!IS_ENABLED (CONFIG_MEMCG_KMEM ) || (flags & __GFP_RECLAIMABLE)) -return KMALLOC_RECLAIM ; -else -return KMALLOC_CGROUP ; -} - -/* -* Figure out which kmalloc slab an allocation of a certain size -* belongs to. -* 0 = zero alloc -* 1 = 65 .. 96 bytes -* 2 = 129 .. 192 bytes -* n = 2^(n-1)+1 .. 2^n -* -* Note: __kmalloc_index() is compile-time optimized, and not runtime optimized; -* typical usage is via kmalloc_index() and therefore evaluated at compile-time. -* Callers where !size_is_constant should only be test modules, where runtime -* overheads of __kmalloc_index() can be tolerated. Also see kmalloc_slab(). -*/ -static __always_inline unsigned int __kmalloc_index(size_t size, -bool size_is_constant) -{ -if (!size) -return 0 ; - -if (size <=KMALLOC_MIN_SIZE ) -return KMALLOC_SHIFT_LOW ; - -if (KMALLOC_MIN_SIZE <=32 && size >64 && size <=96 ) -return 1 ; -if (KMALLOC_MIN_SIZE <=64 && size >128 && size <=192 ) -return 2 ; -if (size <=8 )return 3 ; -if (size <=16 )return 4 ; -if (size <=32 )return 5 ; -if (size <=64 )return 6 ; -if (size <=128 )return 7 ; -if (size <=256 )return 8 ; -if (size <=512 )return 9 ; -if (size <=1024 )return 10 ; -if (size <=2 *1024 )return 11 ; -if (size <=4 *1024 )return 12 ; -if (size <=8 *1024 )return 13 ; -if (size <=16 *1024 )return 14 ; -if (size <=32 *1024 )return 15 ; -if (size <=64 *1024 )return 16 ; -if (size <=128 *1024 )return 17 ; -if (size <=256 *1024 )return 18 ; -if (size <=512 *1024 )return 19 ; -if (size <=1024 *1024 )return 20 ; -if (size <=2 *1024 *1024 )return 21 ; - -if (!IS_ENABLED (CONFIG_PROFILE_ALL_BRANCHES ) && size_is_constant) -BUILD_BUG_ON_MSG (1 ,"unexpected size in kmalloc_index()" ); -else -BUG (); - -/* Will never be reached. Needed because the compiler may complain */ -return -1 ; -} -static_assert (PAGE_SHIFT <=20 ); -#define kmalloc_index (s) __kmalloc_index(s, true) -#endif /* !CONFIG_SLOB */ -void *__kmalloc (size_t size,gfp_t flags) __assume_kmalloc_alignment__alloc_size(1) ;/** @@ -567,57 +417,15 @@ void *kmalloc_large_node(size_t size, gfp_t flags, int node) __assume_page_align* Try really hard to succeed the allocation but fail * eventually. */ -#ifndef CONFIG_SLOB -static __always_inline __alloc_size(1) void *kmalloc(size_t size, gfp_t flags) -{ -if (__builtin_constant_p (size) && size) { -unsigned int index; - -if (size >KMALLOC_MAX_CACHE_SIZE ) -return kmalloc_large (size, flags); - - index =kmalloc_index (size); -return kmalloc_trace ( - kmalloc_caches[kmalloc_type (flags)][index], - flags, size); - } -return __kmalloc (size, flags); -} -#else static __always_inline __alloc_size(1) void *kmalloc(size_t size, gfp_t flags) { -if (__builtin_constant_p (size) && size >KMALLOC_MAX_CACHE_SIZE ) -return kmalloc_large (size, flags); - -return __kmalloc (size, flags); +return kmalloc_large (size, flags); } -#endif -#ifndef CONFIG_SLOB static __always_inline __alloc_size(1) void *kmalloc_node(size_t size, gfp_t flags, int node) { -if (__builtin_constant_p (size) && size) { -unsigned int index; - -if (size >KMALLOC_MAX_CACHE_SIZE ) -return kmalloc_large_node (size, flags, node); - - index =kmalloc_index (size); -return kmalloc_node_trace ( - kmalloc_caches[kmalloc_type (flags)][index], - flags, node, size); - } -return __kmalloc_node (size, flags, node); +return kmalloc_large_node (size, flags, node); } -#else -static __always_inline __alloc_size(1) void *kmalloc_node(size_t size, gfp_t flags, int node) -{ -if (__builtin_constant_p (size) && size >KMALLOC_MAX_CACHE_SIZE ) -return kmalloc_large_node (size, flags, node); - -return __kmalloc_node (size, flags, node); -} -#endif /** * kmalloc_array - allocate memory for an array. @@ -785,12 +593,7 @@ size_t kmalloc_size_roundup(size_t size);void __init kmem_cache_init_late (void ); -#if defined(CONFIG_SMP ) && defined(CONFIG_SLAB ) -int slab_prepare_cpu (unsigned int cpu); -int slab_dead_cpu (unsigned int cpu); -#else #define slab_prepare_cpu NULL#define slab_dead_cpu NULL -#endif #endif /* _LINUX_SLAB_H */ include/linux/slab_def.h deleted +0
-124@@ -1,124 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0 */ -#ifndef _LINUX_SLAB_DEF_H -#define _LINUX_SLAB_DEF_H - -#include <linux/kfence.h> -#include <linux/reciprocal_div.h> - -/* -* Definitions unique to the original Linux SLAB allocator. -*/ - -struct kmem_cache { -struct array_cache __percpu *cpu_cache; - -/* 1) Cache tunables. Protected by slab_mutex */ -unsigned int batchcount; -unsigned int limit; -unsigned int shared; - -unsigned int size; -struct reciprocal_value reciprocal_buffer_size; -/* 2) touched by every alloc & free from the backend */ - -slab_flags_t flags;/* constant flags */ -unsigned int num;/* # of objs per slab */ - -/* 3) cache_grow/shrink */ -/* order of pgs per slab (2^n) */ -unsigned int gfporder; - -/* force GFP flags, e.g. GFP_DMA */ -gfp_t allocflags; - -size_t colour;/* cache colouring range */ -unsigned int colour_off;/* colour offset */ -unsigned int freelist_size; - -/* constructor func */ -void (*ctor)(void *obj); - -/* 4) cache creation/removal */ -const char *name; -struct list_head list; -int refcount; -int object_size; -int align; - -/* 5) statistics */ -#ifdef CONFIG_DEBUG_SLAB -unsigned long num_active; -unsigned long num_allocations; -unsigned long high_mark; -unsigned long grown; -unsigned long reaped; -unsigned long errors; -unsigned long max_freeable; -unsigned long node_allocs; -unsigned long node_frees; -unsigned long node_overflow; -atomic_t allochit; -atomic_t allocmiss; -atomic_t freehit; -atomic_t freemiss; - -/* -* If debugging is enabled, then the allocator can add additional -* fields and/or padding to every object. 'size' contains the total -* object size including these internal fields, while 'obj_offset' -* and 'object_size' contain the offset to the user object and its -* size. -*/ -int obj_offset; -#endif /* CONFIG_DEBUG_SLAB */ - -#ifdef CONFIG_KASAN_GENERIC -struct kasan_cache kasan_info; -#endif - -#ifdef CONFIG_SLAB_FREELIST_RANDOM -unsigned int *random_seq; -#endif - -#ifdef CONFIG_HARDENED_USERCOPY -unsigned int useroffset;/* Usercopy region offset */ -unsigned int usersize;/* Usercopy region size */ -#endif - -struct kmem_cache_node *node[MAX_NUMNODES ]; -}; - -static inline void *nearest_obj (struct kmem_cache *cache,const struct slab *slab, -void *x) -{ -void *object = x - (x - slab->s_mem) % cache->size; -void *last_object = slab->s_mem + (cache->num -1 ) * cache->size; - -if (unlikely (object > last_object)) -return last_object; -else -return object; -} - -/* -* We want to avoid an expensive divide : (offset / cache->size) -* Using the fact that size is a constant for a particular cache, -* we can replace (offset / cache->size) by -* reciprocal_divide(offset, cache->reciprocal_buffer_size) -*/ -static inline unsigned int obj_to_index (const struct kmem_cache *cache, -const struct slab *slab,void *obj) -{ -u32 offset = (obj - slab->s_mem); -return reciprocal_divide (offset, cache->reciprocal_buffer_size); -} - -static inline int objs_per_slab (const struct kmem_cache *cache, -const struct slab *slab) -{ -if (is_kfence_address (slab_address (slab))) -return 1 ; -return cache->num; -} - -#endif /* _LINUX_SLAB_DEF_H */ include/linux/slub_def.h deleted +0
-198@@ -1,198 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0 */ -#ifndef _LINUX_SLUB_DEF_H -#define _LINUX_SLUB_DEF_H - -/* -* SLUB : A Slab allocator without object queues. -* -* (C) 2007 SGI, Christoph Lameter -*/ -#include <linux/kfence.h> -#include <linux/kobject.h> -#include <linux/reciprocal_div.h> -#include <linux/local_lock.h> - -enum stat_item { -ALLOC_FASTPATH ,/* Allocation from cpu slab */ -ALLOC_SLOWPATH ,/* Allocation by getting a new cpu slab */ -FREE_FASTPATH ,/* Free to cpu slab */ -FREE_SLOWPATH ,/* Freeing not to cpu slab */ -FREE_FROZEN ,/* Freeing to frozen slab */ -FREE_ADD_PARTIAL ,/* Freeing moves slab to partial list */ -FREE_REMOVE_PARTIAL ,/* Freeing removes last object */ -ALLOC_FROM_PARTIAL ,/* Cpu slab acquired from node partial list */ -ALLOC_SLAB ,/* Cpu slab acquired from page allocator */ -ALLOC_REFILL ,/* Refill cpu slab from slab freelist */ -ALLOC_NODE_MISMATCH ,/* Switching cpu slab */ -FREE_SLAB ,/* Slab freed to the page allocator */ -CPUSLAB_FLUSH ,/* Abandoning of the cpu slab */ -DEACTIVATE_FULL ,/* Cpu slab was full when deactivated */ -DEACTIVATE_EMPTY ,/* Cpu slab was empty when deactivated */ -DEACTIVATE_TO_HEAD ,/* Cpu slab was moved to the head of partials */ -DEACTIVATE_TO_TAIL ,/* Cpu slab was moved to the tail of partials */ -DEACTIVATE_REMOTE_FREES ,/* Slab contained remotely freed objects */ -DEACTIVATE_BYPASS ,/* Implicit deactivation */ -ORDER_FALLBACK ,/* Number of times fallback was necessary */ -CMPXCHG_DOUBLE_CPU_FAIL ,/* Failure of this_cpu_cmpxchg_double */ -CMPXCHG_DOUBLE_FAIL ,/* Number of times that cmpxchg double did not match */ -CPU_PARTIAL_ALLOC ,/* Used cpu partial on alloc */ -CPU_PARTIAL_FREE ,/* Refill cpu partial on free */ -CPU_PARTIAL_NODE ,/* Refill cpu partial from node partial */ -CPU_PARTIAL_DRAIN ,/* Drain cpu partial to node partial */ -NR_SLUB_STAT_ITEMS }; - -#ifndef CONFIG_SLUB_TINY -/* -* When changing the layout, make sure freelist and tid are still compatible -* with this_cpu_cmpxchg_double() alignment requirements. -*/ -struct kmem_cache_cpu { -void **freelist;/* Pointer to next available object */ -unsigned long tid;/* Globally unique transaction id */ -struct slab *slab;/* The slab from which we are allocating */ -#ifdef CONFIG_SLUB_CPU_PARTIAL -struct slab *partial;/* Partially allocated frozen slabs */ -#endif -local_lock_t lock;/* Protects the fields above */ -#ifdef CONFIG_SLUB_STATS -unsigned stat[NR_SLUB_STAT_ITEMS ]; -#endif -}; -#endif /* CONFIG_SLUB_TINY */ - -#ifdef CONFIG_SLUB_CPU_PARTIAL -#define slub_percpu_partial (c) ((c)->partial) - -#define slub_set_percpu_partial (c, p) \ -({ \ - slub_percpu_partial(c) = (p)->next; \ -}) - -#define slub_percpu_partial_read_once (c) READ_ONCE(slub_percpu_partial(c)) -#else -#define slub_percpu_partial (c) NULL - -#define slub_set_percpu_partial (c, p) - -#define slub_percpu_partial_read_once (c) NULL -#endif // CONFIG_SLUB_CPU_PARTIAL - -/* -* Word size structure that can be atomically updated or read and that -* contains both the order and the number of objects that a slab of the -* given order would contain. -*/ -struct kmem_cache_order_objects { -unsigned int x; -}; - -/* -* Slab cache management. -*/ -struct kmem_cache { -#ifndef CONFIG_SLUB_TINY -struct kmem_cache_cpu __percpu *cpu_slab; -#endif -/* Used for retrieving partial slabs, etc. */ -slab_flags_t flags; -unsigned long min_partial; -unsigned int size;/* The size of an object including metadata */ -unsigned int object_size;/* The size of an object without metadata */ -struct reciprocal_value reciprocal_size; -unsigned int offset;/* Free pointer offset */ -#ifdef CONFIG_SLUB_CPU_PARTIAL -/* Number of per cpu partial objects to keep around */ -unsigned int cpu_partial; -/* Number of per cpu partial slabs to keep around */ -unsigned int cpu_partial_slabs; -#endif -struct kmem_cache_order_objects oo; - -/* Allocation and freeing of slabs */ -struct kmem_cache_order_objects min; -gfp_t allocflags;/* gfp flags to use on each alloc */ -int refcount;/* Refcount for slab cache destroy */ -void (*ctor)(void *); -unsigned int inuse;/* Offset to metadata */ -unsigned int align;/* Alignment */ -unsigned int red_left_pad;/* Left redzone padding size */ -const char *name;/* Name (only for display!) */ -struct list_head list;/* List of slab caches */ -#ifdef CONFIG_SYSFS -struct kobject kobj;/* For sysfs */ -#endif -#ifdef CONFIG_SLAB_FREELIST_HARDENED -unsigned long random; -#endif - -#ifdef CONFIG_NUMA -/* -* Defragmentation by allocating from a remote node. -*/ -unsigned int remote_node_defrag_ratio; -#endif - -#ifdef CONFIG_SLAB_FREELIST_RANDOM -unsigned int *random_seq; -#endif - -#ifdef CONFIG_KASAN_GENERIC -struct kasan_cache kasan_info; -#endif - -#ifdef CONFIG_HARDENED_USERCOPY -unsigned int useroffset;/* Usercopy region offset */ -unsigned int usersize;/* Usercopy region size */ -#endif - -struct kmem_cache_node *node[MAX_NUMNODES ]; -}; - -#if defined(CONFIG_SYSFS ) && !defined(CONFIG_SLUB_TINY ) -#define SLAB_SUPPORTS_SYSFS -void sysfs_slab_unlink (struct kmem_cache *); -void sysfs_slab_release (struct kmem_cache *); -#else -static inline void sysfs_slab_unlink (struct kmem_cache *s) -{ -} -static inline void sysfs_slab_release (struct kmem_cache *s) -{ -} -#endif - -void *fixup_red_left (struct kmem_cache *s,void *p); - -static inline void *nearest_obj (struct kmem_cache *cache,const struct slab *slab, -void *x) { -void *object = x - (x -slab_address (slab)) % cache->size; -void *last_object =slab_address (slab) + - (slab->objects -1 ) * cache->size; -void *result = (unlikely (object > last_object)) ? last_object : object; - - result =fixup_red_left (cache, result); -return result; -} - -/* Determine object index from a given position */ -static inline unsigned int __obj_to_index (const struct kmem_cache *cache, -void *addr,void *obj) -{ -return reciprocal_divide (kasan_reset_tag (obj) - addr, - cache->reciprocal_size); -} - -static inline unsigned int obj_to_index (const struct kmem_cache *cache, -const struct slab *slab,void *obj) -{ -if (is_kfence_address (obj)) -return 0 ; -return __obj_to_index (cache,slab_address (slab), obj); -} - -static inline int objs_per_slab (const struct kmem_cache *cache, -const struct slab *slab) -{ -return slab->objects; -} -#endif /* _LINUX_SLUB_DEF_H */ init/Kconfig +1
-1@@ -973,7 +973,7 @@ config MEMCG config MEMCG_KMEM bool - depends on MEMCG && !SLOB + depends on MEMCG && BROKEN default y config BLK_CGROUPmm/Kconfig +4
-130@@ -210,134 +210,9 @@ config ZSMALLOC_CHAIN_SIZE For more information, see zsmalloc documentation. -menu "SLAB allocator options" - -choice - prompt "Choose SLAB allocator" - default SLUB - help - This option allows to select a slab allocator. - -config SLAB - bool "SLAB" - depends on !PREEMPT_RT - select HAVE_HARDENED_USERCOPY_ALLOCATOR - help - The regular slab allocator that is established and known to work - well in all environments. It organizes cache hot objects in - per cpu and per node queues. - -config SLUB - bool "SLUB (Unqueued Allocator)" - select HAVE_HARDENED_USERCOPY_ALLOCATOR - help - SLUB is a slab allocator that minimizes cache line usage - instead of managing queues of cached objects (SLAB approach). - Per cpu caching is realized using slabs of objects instead - of queues of objects. SLUB can use memory efficiently - and has enhanced diagnostics. SLUB is the default choice for - a slab allocator. - -config SLOB_DEPRECATED - depends on EXPERT - bool "SLOB (Simple Allocator - DEPRECATED)" - depends on !PREEMPT_RT - help - Deprecated and scheduled for removal in a few cycles. SLUB - recommended as replacement. CONFIG_SLUB_TINY can be considered - on systems with 16MB or less RAM. - - If you need SLOB to stay, please contact [email protected] and - people listed in the SLAB ALLOCATOR section of MAINTAINERS file, - with your use case. - - SLOB replaces the stock allocator with a drastically simpler - allocator. SLOB is generally more space efficient but - does not perform as well on large systems. - -endchoice - -config SLOB - bool - default y - depends on SLOB_DEPRECATED - -config SLUB_TINY - bool "Configure SLUB for minimal memory footprint" - depends on SLUB && EXPERT - select SLAB_MERGE_DEFAULT - help - Configures the SLUB allocator in a way to achieve minimal memory - footprint, sacrificing scalability, debugging and other features. - This is intended only for the smallest system that had used the - SLOB allocator and is not recommended for systems with more than - 16MB RAM. - - If unsure, say N. - -config SLAB_MERGE_DEFAULT - bool "Allow slab caches to be merged" - default y - depends on SLAB || SLUB - help - For reduced kernel memory fragmentation, slab caches can be - merged when they share the same size and other characteristics. - This carries a risk of kernel heap overflows being able to - overwrite objects from merged caches (and more easily control - cache layout), which makes such heap attacks easier to exploit - by attackers. By keeping caches unmerged, these kinds of exploits - can usually only damage objects in the same cache. To disable - merging at runtime, "slab_nomerge" can be passed on the kernel - command line. - -config SLAB_FREELIST_RANDOM - bool "Randomize slab freelist" - depends on SLAB || (SLUB && !SLUB_TINY) - help - Randomizes the freelist order used on creating new pages. This - security feature reduces the predictability of the kernel slab - allocator against heap overflows. - -config SLAB_FREELIST_HARDENED - bool "Harden slab freelist metadata" - depends on SLAB || (SLUB && !SLUB_TINY) - help - Many kernel heap attacks try to target slab cache metadata and - other infrastructure. This options makes minor performance - sacrifices to harden the kernel slab allocator against common - freelist exploit methods. Some slab implementations have more - sanity-checking than others. This option is most effective with - CONFIG_SLUB. - -config SLUB_STATS - default n - bool "Enable SLUB performance statistics" - depends on SLUB && SYSFS && !SLUB_TINY - help - SLUB statistics are useful to debug SLUBs allocation behavior in - order find ways to optimize the allocator. This should never be - enabled for production use since keeping statistics slows down - the allocator by a few percentage points. The slabinfo command - supports the determination of the most active slabs to figure - out which slabs are relevant to a particular load. - Try running: slabinfo -DA - -config SLUB_CPU_PARTIAL - default y - depends on SLUB && SMP && !SLUB_TINY - bool "SLUB per cpu partial cache" - help - Per cpu partial caches accelerate objects allocation and freeing - that is local to a processor at the price of more indeterminism - in the latency of the free. On overflow these caches will be cleared - which requires the taking of locks that may cause latency spikes. - Typically one would choose no for a realtime system. - -endmenu # SLAB allocator options - config SHUFFLE_PAGE_ALLOCATOR bool "Page allocator randomization" - default SLAB_FREELIST_RANDOM && ACPI_NUMA + default ACPI_NUMA help Randomization of the page allocator improves the average utilization of a direct-mapped memory-side-cache. See section@@ -345,10 +220,9 @@ config SHUFFLE_PAGE_ALLOCATOR 6.2a specification for an example of how a platform advertises the presence of a memory-side-cache. There are also incidental security benefits as it reduces the predictability of page - allocations to compliment SLAB_FREELIST_RANDOM, but the - default granularity of shuffling on the "MAX_ORDER - 1" i.e, - 10th order of pages is selected based on cache utilization - benefits on x86. + allocations, but the default granularity of shuffling on the + "MAX_ORDER - 1" i.e, 10th order of pages is selected based on + cache utilization benefits on x86. While the randomization improves cache utilization it may negatively impact workloads on platforms without a cache. Formm/Makefile +0
-10@@ -4,16 +4,12 @@ # KASAN_SANITIZE_slab_common.o := n -KASAN_SANITIZE_slab.o := n -KASAN_SANITIZE_slub.o := n KCSAN_SANITIZE_kmemleak.o := n # These produce frequent data race reports: most of them are due to races on # the same word but accesses to different bits of that word. Re-enable KCSAN # for these when we have more consensus on what to do about them. KCSAN_SANITIZE_slab_common.o := n -KCSAN_SANITIZE_slab.o := n -KCSAN_SANITIZE_slub.o := n KCSAN_SANITIZE_page_alloc.o := n # But enable explicit instrumentation for memory barriers. KCSAN_INSTRUMENT_BARRIERS := y@@ -22,9 +18,6 @@ KCSAN_INSTRUMENT_BARRIERS := y # flaky coverage that is not a function of syscall inputs. E.g. slab is out of # free pages, or a task is migrated between nodes. KCOV_INSTRUMENT_slab_common.o := n -KCOV_INSTRUMENT_slob.o := n -KCOV_INSTRUMENT_slab.o := n -KCOV_INSTRUMENT_slub.o := n KCOV_INSTRUMENT_page_alloc.o := n KCOV_INSTRUMENT_debug-pagealloc.o := n KCOV_INSTRUMENT_kmemleak.o := n@@ -81,12 +74,9 @@ obj-$(CONFIG_HUGETLB_PAGE_OPTIMIZE_VMEMMAP) += hugetlb_vmemmap.o obj-$(CONFIG_NUMA) += mempolicy.o obj-$(CONFIG_SPARSEMEM) += sparse.o obj-$(CONFIG_SPARSEMEM_VMEMMAP) += sparse-vmemmap.o -obj-$(CONFIG_SLOB) += slob.o obj-$(CONFIG_MMU_NOTIFIER) += mmu_notifier.o obj-$(CONFIG_KSM) += ksm.o obj-$(CONFIG_PAGE_POISONING) += page_poison.o -obj-$(CONFIG_SLAB) += slab.o -obj-$(CONFIG_SLUB) += slub.o obj-$(CONFIG_KASAN) += kasan/ obj-$(CONFIG_KFENCE) += kfence/ obj-$(CONFIG_KMSAN) += kmsan/mm/slab.c deleted +0
-4046@@ -1,4046 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0 -/* -* linux/mm/slab.c -* Written by Mark Hemment, 1996/97. -* ([email protected]) -* -* kmem_cache_destroy() + some cleanup - 1999 Andrea Arcangeli -* -* Major cleanup, different bufctl logic, per-cpu arrays -* (c) 2000 Manfred Spraul -* -* Cleanup, make the head arrays unconditional, preparation for NUMA -* (c) 2002 Manfred Spraul -* -* An implementation of the Slab Allocator as described in outline in; -* UNIX Internals: The New Frontiers by Uresh Vahalia -* Pub: Prentice Hall ISBN 0-13-101908-2 -* or with a little more detail in; -* The Slab Allocator: An Object-Caching Kernel Memory Allocator -* Jeff Bonwick (Sun Microsystems). -* Presented at: USENIX Summer 1994 Technical Conference -* -* The memory is organized in caches, one cache for each object type. -* (e.g. inode_cache, dentry_cache, buffer_head, vm_area_struct) -* Each cache consists out of many slabs (they are small (usually one -* page long) and always contiguous), and each slab contains multiple -* initialized objects. -* -* This means, that your constructor is used only for newly allocated -* slabs and you must pass objects with the same initializations to -* kmem_cache_free. -* -* Each cache can only support one memory type (GFP_DMA, GFP_HIGHMEM, -* normal). If you need a special memory type, then must create a new -* cache for that memory type. -* -* In order to reduce fragmentation, the slabs are sorted in 3 groups: -* full slabs with 0 free objects -* partial slabs -* empty slabs with no allocated objects -* -* If partial slabs exist, then new allocations come from these slabs, -* otherwise from empty slabs or new slabs are allocated. -* -* kmem_cache_destroy() CAN CRASH if you try to allocate from the cache -* during kmem_cache_destroy(). The caller must prevent concurrent allocs. -* -* Each cache has a short per-cpu head array, most allocs -* and frees go into that array, and if that array overflows, then 1/2 -* of the entries in the array are given back into the global cache. -* The head array is strictly LIFO and should improve the cache hit rates. -* On SMP, it additionally reduces the spinlock operations. -* -* The c_cpuarray may not be read with enabled local interrupts - -* it's changed with a smp_call_function(). -* -* SMP synchronization: -* constructors and destructors are called without any locking. -* Several members in struct kmem_cache and struct slab never change, they -* are accessed without any locking. -* The per-cpu arrays are never accessed from the wrong cpu, no locking, -* and local interrupts are disabled so slab code is preempt-safe. -* The non-constant members are protected with a per-cache irq spinlock. -* -* Many thanks to Mark Hemment, who wrote another per-cpu slab patch -* in 2000 - many ideas in the current implementation are derived from -* his patch. -* -* Further notes from the original documentation: -* -* 11 April '97. Started multi-threading - markhe -* The global cache-chain is protected by the mutex 'slab_mutex'. -* The sem is only needed when accessing/extending the cache-chain, which -* can never happen inside an interrupt (kmem_cache_create(), -* kmem_cache_shrink() and kmem_cache_reap()). -* -* At present, each engine can be growing a cache. This should be blocked. -* -* 15 March 2005. NUMA slab allocator. -* Shai Fultheim <[email protected]>. -* Shobhit Dayal <[email protected]> -* Alok N Kataria <[email protected]> -* Christoph Lameter <[email protected]> -* -* Modified the slab allocator to be node aware on NUMA systems. -* Each node has its own list of partial, free and full slabs. -* All object allocations for a node occur from node specific slab lists. -*/ - -#include <linux/slab.h> -#include <linux/mm.h> -#include <linux/poison.h> -#include <linux/swap.h> -#include <linux/cache.h> -#include <linux/interrupt.h> -#include <linux/init.h> -#include <linux/compiler.h> -#include <linux/cpuset.h> -#include <linux/proc_fs.h> -#include <linux/seq_file.h> -#include <linux/notifier.h> -#include <linux/kallsyms.h> -#include <linux/kfence.h> -#include <linux/cpu.h> -#include <linux/sysctl.h> -#include <linux/module.h> -#include <linux/rcupdate.h> -#include <linux/string.h> -#include <linux/uaccess.h> -#include <linux/nodemask.h> -#include <linux/kmemleak.h> -#include <linux/mempolicy.h> -#include <linux/mutex.h> -#include <linux/fault-inject.h> -#include <linux/rtmutex.h> -#include <linux/reciprocal_div.h> -#include <linux/debugobjects.h> -#include <linux/memory.h> -#include <linux/prefetch.h> -#include <linux/sched/task_stack.h> - -#include <net/sock.h> - -#include <asm/cacheflush.h> -#include <asm/tlbflush.h> -#include <asm/page.h> - -#include <trace/events/kmem.h> - -#include "internal.h" - -#include "slab.h" - -/* -* DEBUG - 1 for kmem_cache_create() to honour; SLAB_RED_ZONE & SLAB_POISON. -* 0 for faster, smaller code (especially in the critical paths). -* -* STATS - 1 to collect stats for /proc/slabinfo. -* 0 for faster, smaller code (especially in the critical paths). -* -* FORCED_DEBUG - 1 enables SLAB_RED_ZONE and SLAB_POISON (if possible) -*/ - -#ifdef CONFIG_DEBUG_SLAB -#define DEBUG 1 -#define STATS 1 -#define FORCED_DEBUG 1 -#else -#define DEBUG 0 -#define STATS 0 -#define FORCED_DEBUG 0 -#endif - -/* Shouldn't this be in a header file somewhere? */ -#define BYTES_PER_WORD sizeof(void *) -#define REDZONE_ALIGN max(BYTES_PER_WORD, __alignof__(unsigned long long)) - -#ifndef ARCH_KMALLOC_FLAGS -#define ARCH_KMALLOC_FLAGS SLAB_HWCACHE_ALIGN -#endif - -#define FREELIST_BYTE_INDEX (((PAGE_SIZE >> BITS_PER_BYTE) \ - <= SLAB_OBJ_MIN_SIZE) ? 1 : 0) - -#if FREELIST_BYTE_INDEX -typedef unsigned char freelist_idx_t ; -#else -typedef unsigned short freelist_idx_t ; -#endif - -#define SLAB_OBJ_MAX_NUM ((1 << sizeof(freelist_idx_t) * BITS_PER_BYTE) - 1) - -/* -* struct array_cache -* -* Purpose: -* - LIFO ordering, to hand out cache-warm objects from _alloc -* - reduce the number of linked list operations -* - reduce spinlock operations -* -* The limit is stored in the per-cpu structure to reduce the data cache -* footprint. -* -*/ -struct array_cache { -unsigned int avail; -unsigned int limit; -unsigned int batchcount; -unsigned int touched; -void *entry[];/* -* Must have this definition in here for the proper -* alignment of array_cache. Also simplifies accessing -* the entries. -*/ -}; - -struct alien_cache { -spinlock_t lock; -struct array_cache ac; -}; - -/* -* Need this for bootstrapping a per node allocator. -*/ -#define NUM_INIT_LISTS (2 * MAX_NUMNODES) -static struct kmem_cache_node __initdata init_kmem_cache_node[NUM_INIT_LISTS ]; -#define CACHE_CACHE 0 -#define SIZE_NODE (MAX_NUMNODES) - -static int drain_freelist (struct kmem_cache *cache, -struct kmem_cache_node *n,int tofree); -static void free_block (struct kmem_cache *cachep,void **objpp,int len, -int node,struct list_head *list); -static void slabs_destroy (struct kmem_cache *cachep,struct list_head *list); -static int enable_cpucache (struct kmem_cache *cachep,gfp_t gfp); -static void cache_reap (struct work_struct *unused); - -static inline void fixup_objfreelist_debug (struct kmem_cache *cachep, -void **list); -static inline void fixup_slab_list (struct kmem_cache *cachep, -struct kmem_cache_node *n,struct slab *slab, -void **list); - -#define INDEX_NODE kmalloc_index(sizeof(struct kmem_cache_node)) - -static void kmem_cache_node_init (struct kmem_cache_node *parent) -{ -INIT_LIST_HEAD (&parent->slabs_full); -INIT_LIST_HEAD (&parent->slabs_partial); -INIT_LIST_HEAD (&parent->slabs_free); - parent->total_slabs =0 ; - parent->free_slabs =0 ; - parent->shared =NULL ; - parent->alien =NULL ; - parent->colour_next =0 ; -raw_spin_lock_init (&parent->list_lock); - parent->free_objects =0 ; - parent->free_touched =0 ; -} - -#define MAKE_LIST (cachep, listp, slab, nodeid) \ - do { \ - INIT_LIST_HEAD(listp); \ - list_splice(&get_node(cachep, nodeid)->slab, listp); \ - } while (0) - -#define MAKE_ALL_LISTS (cachep, ptr, nodeid) \ - do { \ - MAKE_LIST((cachep), (&(ptr)->slabs_full), slabs_full, nodeid); \ - MAKE_LIST((cachep), (&(ptr)->slabs_partial), slabs_partial, nodeid); \ - MAKE_LIST((cachep), (&(ptr)->slabs_free), slabs_free, nodeid); \ - } while (0) - -#define CFLGS_OBJFREELIST_SLAB ((slab_flags_t __force)0x40000000U) -#define CFLGS_OFF_SLAB ((slab_flags_t __force)0x80000000U) -#define OBJFREELIST_SLAB (x) ((x)->flags & CFLGS_OBJFREELIST_SLAB) -#define OFF_SLAB (x) ((x)->flags & CFLGS_OFF_SLAB) - -#define BATCHREFILL_LIMIT 16 -/* -* Optimization question: fewer reaps means less probability for unnecessary -* cpucache drain/refill cycles. -* -* OTOH the cpuarrays can contain lots of objects, -* which could lock up otherwise freeable slabs. -*/ -#define REAPTIMEOUT_AC (2*HZ) -#define REAPTIMEOUT_NODE (4*HZ) - -#if STATS -#define STATS_INC_ACTIVE (x) ((x)->num_active++) -#define STATS_DEC_ACTIVE (x) ((x)->num_active--) -#define STATS_INC_ALLOCED (x) ((x)->num_allocations++) -#define STATS_INC_GROWN (x) ((x)->grown++) -#define STATS_ADD_REAPED (x, y) ((x)->reaped += (y)) -#define STATS_SET_HIGH (x) \ - do { \ - if ((x)->num_active > (x)->high_mark) \ - (x)->high_mark = (x)->num_active; \ - } while (0) -#define STATS_INC_ERR (x) ((x)->errors++) -#define STATS_INC_NODEALLOCS (x) ((x)->node_allocs++) -#define STATS_INC_NODEFREES (x) ((x)->node_frees++) -#define STATS_INC_ACOVERFLOW (x) ((x)->node_overflow++) -#define STATS_SET_FREEABLE (x, i) \ - do { \ - if ((x)->max_freeable < i) \ - (x)->max_freeable = i; \ - } while (0) -#define STATS_INC_ALLOCHIT (x) atomic_inc(&(x)->allochit) -#define STATS_INC_ALLOCMISS (x) atomic_inc(&(x)->allocmiss) -#define STATS_INC_FREEHIT (x) atomic_inc(&(x)->freehit) -#define STATS_INC_FREEMISS (x) atomic_inc(&(x)->freemiss) -#else -#define STATS_INC_ACTIVE (x) do { } while (0) -#define STATS_DEC_ACTIVE (x) do { } while (0) -#define STATS_INC_ALLOCED (x) do { } while (0) -#define STATS_INC_GROWN (x) do { } while (0) -#define STATS_ADD_REAPED (x, y) do { (void)(y); } while (0) -#define STATS_SET_HIGH (x) do { } while (0) -#define STATS_INC_ERR (x) do { } while (0) -#define STATS_INC_NODEALLOCS (x) do { } while (0) -#define STATS_INC_NODEFREES (x) do { } while (0) -#define STATS_INC_ACOVERFLOW (x) do { } while (0) -#define STATS_SET_FREEABLE (x, i) do { } while (0) -#define STATS_INC_ALLOCHIT (x) do { } while (0) -#define STATS_INC_ALLOCMISS (x) do { } while (0) -#define STATS_INC_FREEHIT (x) do { } while (0) -#define STATS_INC_FREEMISS (x) do { } while (0) -#endif - -#if DEBUG - -/* -* memory layout of objects: -* 0 : objp -* 0 .. cachep->obj_offset - BYTES_PER_WORD - 1: padding. This ensures that -* the end of an object is aligned with the end of the real -* allocation. Catches writes behind the end of the allocation. -* cachep->obj_offset - BYTES_PER_WORD .. cachep->obj_offset - 1: -* redzone word. -* cachep->obj_offset: The real object. -* cachep->size - 2* BYTES_PER_WORD: redzone word [BYTES_PER_WORD long] -* cachep->size - 1* BYTES_PER_WORD: last caller address -* [BYTES_PER_WORD long] -*/ -static int obj_offset (struct kmem_cache *cachep) -{ -return cachep->obj_offset; -} - -static unsigned long long *dbg_redzone1 (struct kmem_cache *cachep,void *objp) -{ -BUG_ON (!(cachep->flags &SLAB_RED_ZONE )); -return (unsigned long long *) (objp +obj_offset (cachep) - -sizeof (unsigned long long )); -} - -static unsigned long long *dbg_redzone2 (struct kmem_cache *cachep,void *objp) -{ -BUG_ON (!(cachep->flags &SLAB_RED_ZONE )); -if (cachep->flags &SLAB_STORE_USER ) -return (unsigned long long *)(objp + cachep->size - -sizeof (unsigned long long ) - -REDZONE_ALIGN ); -return (unsigned long long *) (objp + cachep->size - -sizeof (unsigned long long )); -} - -static void **dbg_userword (struct kmem_cache *cachep,void *objp) -{ -BUG_ON (!(cachep->flags &SLAB_STORE_USER )); -return (void **)(objp + cachep->size -BYTES_PER_WORD ); -} - -#else - -#define obj_offset (x) 0 -#define dbg_redzone1 (cachep, objp) ({BUG(); (unsigned long long *)NULL;}) -#define dbg_redzone2 (cachep, objp) ({BUG(); (unsigned long long *)NULL;}) -#define dbg_userword (cachep, objp) ({BUG(); (void **)NULL;}) - -#endif - -/* -* Do not go above this order unless 0 objects fit into the slab or -* overridden on the command line. -*/ -#define SLAB_MAX_ORDER_HI 1 -#define SLAB_MAX_ORDER_LO 0 -static int slab_max_order =SLAB_MAX_ORDER_LO ; -static bool slab_max_order_set__initdata ; - -static inline void *index_to_obj (struct kmem_cache *cache, -const struct slab *slab,unsigned int idx) -{ -return slab->s_mem + cache->size * idx; -} - -#define BOOT_CPUCACHE_ENTRIES 1 -/* internal cache of cache description objs */ -static struct kmem_cache kmem_cache_boot = { - .batchcount =1 , - .limit =BOOT_CPUCACHE_ENTRIES , - .shared =1 , - .size =sizeof (struct kmem_cache ), - .name ="kmem_cache" , -}; - -static DEFINE_PER_CPU(struct delayed_work, slab_reap_work); - -static inline struct array_cache *cpu_cache_get (struct kmem_cache *cachep) -{ -return this_cpu_ptr (cachep->cpu_cache); -} - -/* -* Calculate the number of objects and left-over bytes for a given buffer size. -*/ -static unsigned int cache_estimate (unsigned long gfporder,size_t buffer_size, -slab_flags_t flags,size_t *left_over) -{ -unsigned int num; -size_t slab_size =PAGE_SIZE << gfporder; - -/* -* The slab management structure can be either off the slab or -* on it. For the latter case, the memory allocated for a -* slab is used for: -* -* - @buffer_size bytes for each object -* - One freelist_idx_t for each object -* -* We don't need to consider alignment of freelist because -* freelist will be at the end of slab page. The objects will be -* at the correct alignment. -* -* If the slab management structure is off the slab, then the -* alignment will already be calculated into the size. Because -* the slabs are all pages aligned, the objects will be at the -* correct alignment when allocated. -*/ -if (flags & (CFLGS_OBJFREELIST_SLAB |CFLGS_OFF_SLAB )) { - num = slab_size / buffer_size; - *left_over = slab_size % buffer_size; - }else { - num = slab_size / (buffer_size +sizeof (freelist_idx_t)); - *left_over = slab_size % - (buffer_size +sizeof (freelist_idx_t)); - } - -return num; -} - -#if DEBUG -#define slab_error (cachep, msg) __slab_error(__func__, cachep, msg) - -static void __slab_error (const char *function,struct kmem_cache *cachep, -char *msg) -{ -pr_err ("slab error in %s(): cache `%s': %s\n" , - function, cachep->name, msg); -dump_stack (); -add_taint (TAINT_BAD_PAGE ,LOCKDEP_NOW_UNRELIABLE ); -} -#endif - -/* -* By default on NUMA we use alien caches to stage the freeing of -* objects allocated from other nodes. This causes massive memory -* inefficiencies when using fake NUMA setup to split memory into a -* large number of small nodes, so it can be disabled on the command -* line -*/ - -static int use_alien_caches__read_mostly =1 ; -static int __init noaliencache_setup (char *s) -{ - use_alien_caches =0 ; -return 1 ; -} -__setup ("noaliencache" , noaliencache_setup); - -static int __init slab_max_order_setup (char *str) -{ -get_option (&str, &slab_max_order); - slab_max_order = slab_max_order <0 ?0 : -min (slab_max_order,MAX_ORDER -1 ); - slab_max_order_set = true; - -return 1 ; -} -__setup ("slab_max_order=" , slab_max_order_setup); - -#ifdef CONFIG_NUMA -/* -* Special reaping functions for NUMA systems called from cache_reap(). -* These take care of doing round robin flushing of alien caches (containing -* objects freed on different nodes from which they were allocated) and the -* flushing of remote pcps by calling drain_node_pages. -*/ -static DEFINE_PER_CPU(unsigned long, slab_reap_node); - -static void init_reap_node (int cpu) -{ -per_cpu (slab_reap_node, cpu) =next_node_in (cpu_to_mem (cpu), - node_online_map); -} - -static void next_reap_node (void ) -{ -int node =__this_cpu_read (slab_reap_node); - - node =next_node_in (node, node_online_map); -__this_cpu_write (slab_reap_node, node); -} - -#else -#define init_reap_node (cpu) do { } while (0) -#define next_reap_node (void) do { } while (0) -#endif - -/* -* Initiate the reap timer running on the target CPU. We run at around 1 to 2Hz -* via the workqueue/eventd. -* Add the CPU number into the expiration time to minimize the possibility of -* the CPUs getting into lockstep and contending for the global cache chain -* lock. -*/ -static void start_cpu_timer (int cpu) -{ -struct delayed_work *reap_work = &per_cpu (slab_reap_work, cpu); - -if (reap_work->work.func ==NULL ) { -init_reap_node (cpu); -INIT_DEFERRABLE_WORK (reap_work, cache_reap); -schedule_delayed_work_on (cpu, reap_work, -__round_jiffies_relative (HZ , cpu)); - } -} - -static void init_arraycache (struct array_cache *ac,int limit,int batch) -{ -if (ac) { - ac->avail =0 ; - ac->limit = limit; - ac->batchcount = batch; - ac->touched =0 ; - } -} - -static struct array_cache *alloc_arraycache (int node,int entries, -int batchcount,gfp_t gfp) -{ -size_t memsize =sizeof (void *) * entries +sizeof (struct array_cache ); -struct array_cache *ac =NULL ; - - ac =kmalloc_node (memsize, gfp, node); -/* -* The array_cache structures contain pointers to free object. -* However, when such objects are allocated or transferred to another -* cache the pointers are not cleared and they could be counted as -* valid references during a kmemleak scan. Therefore, kmemleak must -* not scan such objects. -*/ -kmemleak_no_scan (ac); -init_arraycache (ac, entries, batchcount); -return ac; -} - -static noinline void cache_free_pfmemalloc(struct kmem_cache *cachep, -struct slab *slab,void *objp) -{ -struct kmem_cache_node *n; -int slab_node; -LIST_HEAD (list); - - slab_node =slab_nid (slab); - n =get_node (cachep, slab_node); - -raw_spin_lock (&n->list_lock); -free_block (cachep, &objp,1 , slab_node, &list); -raw_spin_unlock (&n->list_lock); - -slabs_destroy (cachep, &list); -} - -/* -* Transfer objects in one arraycache to another. -* Locking must be handled by the caller. -* -* Return the number of entries transferred. -*/ -static int transfer_objects (struct array_cache *to, -struct array_cache *from,unsigned int max) -{ -/* Figure out how many entries to transfer */ -int nr =min3 (from->avail, max, to->limit - to->avail); - -if (!nr) -return 0 ; - -memcpy (to->entry + to->avail, from->entry + from->avail - nr, -sizeof (void *) *nr); - - from->avail -= nr; - to->avail += nr; -return nr; -} - -/* &alien->lock must be held by alien callers. */ -static __always_inline void __free_one(struct array_cache *ac, void *objp) -{ -/* Avoid trivial double-free. */ -if (IS_ENABLED (CONFIG_SLAB_FREELIST_HARDENED ) && -WARN_ON_ONCE (ac->avail >0 && ac->entry[ac->avail -1 ] == objp)) -return ; - ac->entry[ac->avail++] = objp; -} - -#ifndef CONFIG_NUMA - -#define drain_alien_cache (cachep, alien) do { } while (0) -#define reap_alien (cachep, n) do { } while (0) - -static inline struct alien_cache **alloc_alien_cache (int node, -int limit,gfp_t gfp) -{ -return NULL ; -} - -static inline void free_alien_cache (struct alien_cache **ac_ptr) -{ -} - -static inline int cache_free_alien (struct kmem_cache *cachep,void *objp) -{ -return 0 ; -} - -static inline gfp_t gfp_exact_node (gfp_t flags) -{ -return flags & ~__GFP_NOFAIL; -} - -#else /* CONFIG_NUMA */ - -static struct alien_cache *__alloc_alien_cache (int node,int entries, -int batch,gfp_t gfp) -{ -size_t memsize =sizeof (void *) * entries +sizeof (struct alien_cache ); -struct alien_cache *alc =NULL ; - - alc =kmalloc_node (memsize, gfp, node); -if (alc) { -kmemleak_no_scan (alc); -init_arraycache (&alc->ac, entries, batch); -spin_lock_init (&alc->lock); - } -return alc; -} - -static struct alien_cache **alloc_alien_cache (int node,int limit,gfp_t gfp) -{ -struct alien_cache **alc_ptr; -int i; - -if (limit >1 ) - limit =12 ; - alc_ptr =kcalloc_node (nr_node_ids,sizeof (void *), gfp, node); -if (!alc_ptr) -return NULL ; - -for_each_node (i) { -if (i == node || !node_online (i)) -continue ; - alc_ptr[i] =__alloc_alien_cache (node, limit,0xbaadf00d , gfp); -if (!alc_ptr[i]) { -for (i--; i >=0 ; i--) -kfree (alc_ptr[i]); -kfree (alc_ptr); -return NULL ; - } - } -return alc_ptr; -} - -static void free_alien_cache (struct alien_cache **alc_ptr) -{ -int i; - -if (!alc_ptr) -return ; -for_each_node (i) -kfree (alc_ptr[i]); -kfree (alc_ptr); -} - -static void __drain_alien_cache (struct kmem_cache *cachep, -struct array_cache *ac,int node, -struct list_head *list) -{ -struct kmem_cache_node *n =get_node (cachep, node); - -if (ac->avail) { -raw_spin_lock (&n->list_lock); -/* -* Stuff objects into the remote nodes shared array first. -* That way we could avoid the overhead of putting the objects -* into the free lists and getting them back later. -*/ -if (n->shared) -transfer_objects (n->shared, ac, ac->limit); - -free_block (cachep, ac->entry, ac->avail, node, list); - ac->avail =0 ; -raw_spin_unlock (&n->list_lock); - } -} - -/* -* Called from cache_reap() to regularly drain alien caches round robin. -*/ -static void reap_alien (struct kmem_cache *cachep,struct kmem_cache_node *n) -{ -int node =__this_cpu_read (slab_reap_node); - -if (n->alien) { -struct alien_cache *alc = n->alien[node]; -struct array_cache *ac; - -if (alc) { - ac = &alc->ac; -if (ac->avail &&spin_trylock_irq (&alc->lock)) { -LIST_HEAD (list); - -__drain_alien_cache (cachep, ac, node, &list); -spin_unlock_irq (&alc->lock); -slabs_destroy (cachep, &list); - } - } - } -} - -static void drain_alien_cache (struct kmem_cache *cachep, -struct alien_cache **alien) -{ -int i =0 ; -struct alien_cache *alc; -struct array_cache *ac; -unsigned long flags; - -for_each_online_node (i) { - alc = alien[i]; -if (alc) { -LIST_HEAD (list); - - ac = &alc->ac; -spin_lock_irqsave (&alc->lock, flags); -__drain_alien_cache (cachep, ac, i, &list); -spin_unlock_irqrestore (&alc->lock, flags); -slabs_destroy (cachep, &list); - } - } -} - -static int __cache_free_alien (struct kmem_cache *cachep,void *objp, -int node,int slab_node) -{ -struct kmem_cache_node *n; -struct alien_cache *alien =NULL ; -struct array_cache *ac; -LIST_HEAD (list); - - n =get_node (cachep, node); -STATS_INC_NODEFREES (cachep); -if (n->alien && n->alien[slab_node]) { - alien = n->alien[slab_node]; - ac = &alien->ac; -spin_lock (&alien->lock); -if (unlikely (ac->avail == ac->limit)) { -STATS_INC_ACOVERFLOW (cachep); -__drain_alien_cache (cachep, ac, slab_node, &list); - } -__free_one (ac, objp); -spin_unlock (&alien->lock); -slabs_destroy (cachep, &list); - }else { - n =get_node (cachep, slab_node); -raw_spin_lock (&n->list_lock); -free_block (cachep, &objp,1 , slab_node, &list); -raw_spin_unlock (&n->list_lock); -slabs_destroy (cachep, &list); - } -return 1 ; -} - -static inline int cache_free_alien (struct kmem_cache *cachep,void *objp) -{ -int slab_node =slab_nid (virt_to_slab (objp)); -int node =numa_mem_id (); -/* -* Make sure we are not freeing an object from another node to the array -* cache on this cpu. -*/ -if (likely (node == slab_node)) -return 0 ; - -return __cache_free_alien (cachep, objp, node, slab_node); -} - -/* -* Construct gfp mask to allocate from a specific node but do not reclaim or -* warn about failures. -*/ -static inline gfp_t gfp_exact_node (gfp_t flags) -{ -return (flags | __GFP_THISNODE | __GFP_NOWARN) & ~(__GFP_RECLAIM|__GFP_NOFAIL); -} -#endif - -static int init_cache_node (struct kmem_cache *cachep,int node,gfp_t gfp) -{ -struct kmem_cache_node *n; - -/* -* Set up the kmem_cache_node for cpu before we can -* begin anything. Make sure some other cpu on this -* node has not already allocated this -*/ - n =get_node (cachep, node); -if (n) { -raw_spin_lock_irq (&n->list_lock); - n->free_limit = (1 +nr_cpus_node (node)) * cachep->batchcount + - cachep->num; -raw_spin_unlock_irq (&n->list_lock); - -return 0 ; - } - - n =kmalloc_node (sizeof (struct kmem_cache_node ), gfp, node); -if (!n) -return -ENOMEM ; - -kmem_cache_node_init (n); - n->next_reap = jiffies +REAPTIMEOUT_NODE + - ((unsigned long )cachep) %REAPTIMEOUT_NODE ; - - n->free_limit = - (1 +nr_cpus_node (node)) * cachep->batchcount + cachep->num; - -/* -* The kmem_cache_nodes don't come and go as CPUs -* come and go. slab_mutex provides sufficient -* protection here. -*/ - cachep->node[node] = n; - -return 0 ; -} - -#if defined(CONFIG_NUMA ) || defined(CONFIG_SMP ) -/* -* Allocates and initializes node for a node on each slab cache, used for -* either memory or cpu hotplug. If memory is being hot-added, the kmem_cache_node -* will be allocated off-node since memory is not yet online for the new node. -* When hotplugging memory or a cpu, existing nodes are not replaced if -* already in use. -* -* Must hold slab_mutex. -*/ -static int init_cache_node_node (int node) -{ -int ret; -struct kmem_cache *cachep; - -list_for_each_entry (cachep, &slab_caches, list) { - ret =init_cache_node (cachep, node,GFP_KERNEL ); -if (ret) -return ret; - } - -return 0 ; -} -#endif - -static int setup_kmem_cache_node (struct kmem_cache *cachep, -int node,gfp_t gfp,bool force_change) -{ -int ret = -ENOMEM ; -struct kmem_cache_node *n; -struct array_cache *old_shared =NULL ; -struct array_cache *new_shared =NULL ; -struct alien_cache **new_alien =NULL ; -LIST_HEAD (list); - -if (use_alien_caches) { - new_alien =alloc_alien_cache (node, cachep->limit, gfp); -if (!new_alien) - goto fail; - } - -if (cachep->shared) { - new_shared =alloc_arraycache (node, - cachep->shared * cachep->batchcount,0xbaadf00d , gfp); -if (!new_shared) - goto fail; - } - - ret =init_cache_node (cachep, node, gfp); -if (ret) - goto fail; - - n =get_node (cachep, node); -raw_spin_lock_irq (&n->list_lock); -if (n->shared && force_change) { -free_block (cachep, n->shared->entry, - n->shared->avail, node, &list); - n->shared->avail =0 ; - } - -if (!n->shared || force_change) { - old_shared = n->shared; - n->shared = new_shared; - new_shared =NULL ; - } - -if (!n->alien) { - n->alien = new_alien; - new_alien =NULL ; - } - -raw_spin_unlock_irq (&n->list_lock); -slabs_destroy (cachep, &list); - -/* -* To protect lockless access to n->shared during irq disabled context. -* If n->shared isn't NULL in irq disabled context, accessing to it is -* guaranteed to be valid until irq is re-enabled, because it will be -* freed after synchronize_rcu(). -*/ -if (old_shared && force_change) -synchronize_rcu (); - -fail: -kfree (old_shared); -kfree (new_shared); -free_alien_cache (new_alien); - -return ret; -} - -#ifdef CONFIG_SMP - -static void cpuup_canceled (long cpu) -{ -struct kmem_cache *cachep; -struct kmem_cache_node *n =NULL ; -int node =cpu_to_mem (cpu); -const struct cpumask *mask =cpumask_of_node (node); - -list_for_each_entry (cachep, &slab_caches, list) { -struct array_cache *nc; -struct array_cache *shared; -struct alien_cache **alien; -LIST_HEAD (list); - - n =get_node (cachep, node); -if (!n) -continue ; - -raw_spin_lock_irq (&n->list_lock); - -/* Free limit for this kmem_cache_node */ - n->free_limit -= cachep->batchcount; - -/* cpu is dead; no one can alloc from it. */ - nc =per_cpu_ptr (cachep->cpu_cache, cpu); -free_block (cachep, nc->entry, nc->avail, node, &list); - nc->avail =0 ; - -if (!cpumask_empty (mask)) { -raw_spin_unlock_irq (&n->list_lock); - goto free_slab; - } - - shared = n->shared; -if (shared) { -free_block (cachep, shared->entry, - shared->avail, node, &list); - n->shared =NULL ; - } - - alien = n->alien; - n->alien =NULL ; - -raw_spin_unlock_irq (&n->list_lock); - -kfree (shared); -if (alien) { -drain_alien_cache (cachep, alien); -free_alien_cache (alien); - } - -free_slab: -slabs_destroy (cachep, &list); - } -/* -* In the previous loop, all the objects were freed to -* the respective cache's slabs, now we can go ahead and -* shrink each nodelist to its limit. -*/ -list_for_each_entry (cachep, &slab_caches, list) { - n =get_node (cachep, node); -if (!n) -continue ; -drain_freelist (cachep, n,INT_MAX ); - } -} - -static int cpuup_prepare (long cpu) -{ -struct kmem_cache *cachep; -int node =cpu_to_mem (cpu); -int err; - -/* -* We need to do this right in the beginning since -* alloc_arraycache's are going to use this list. -* kmalloc_node allows us to add the slab to the right -* kmem_cache_node and not this cpu's kmem_cache_node -*/ - err =init_cache_node_node (node); -if (err <0 ) - goto bad; - -/* -* Now we can go ahead with allocating the shared arrays and -* array caches -*/ -list_for_each_entry (cachep, &slab_caches, list) { - err =setup_kmem_cache_node (cachep, node,GFP_KERNEL , false); -if (err) - goto bad; - } - -return 0 ; -bad: -cpuup_canceled (cpu); -return -ENOMEM ; -} - -int slab_prepare_cpu (unsigned int cpu) -{ -int err; - -mutex_lock (&slab_mutex); - err =cpuup_prepare (cpu); -mutex_unlock (&slab_mutex); -return err; -} - -/* -* This is called for a failed online attempt and for a successful -* offline. -* -* Even if all the cpus of a node are down, we don't free the -* kmem_cache_node of any cache. This is to avoid a race between cpu_down, and -* a kmalloc allocation from another cpu for memory from the node of -* the cpu going down. The kmem_cache_node structure is usually allocated from -* kmem_cache_create() and gets destroyed at kmem_cache_destroy(). -*/ -int slab_dead_cpu (unsigned int cpu) -{ -mutex_lock (&slab_mutex); -cpuup_canceled (cpu); -mutex_unlock (&slab_mutex); -return 0 ; -} -#endif - -static int slab_online_cpu (unsigned int cpu) -{ -start_cpu_timer (cpu); -return 0 ; -} - -static int slab_offline_cpu (unsigned int cpu) -{ -/* -* Shutdown cache reaper. Note that the slab_mutex is held so -* that if cache_reap() is invoked it cannot do anything -* expensive but will only modify reap_work and reschedule the -* timer. -*/ -cancel_delayed_work_sync (&per_cpu (slab_reap_work, cpu)); -/* Now the cache_reaper is guaranteed to be not running. */ -per_cpu (slab_reap_work, cpu).work.func =NULL ; -return 0 ; -} - -#if defined(CONFIG_NUMA ) -/* -* Drains freelist for a node on each slab cache, used for memory hot-remove. -* Returns -EBUSY if all objects cannot be drained so that the node is not -* removed. -* -* Must hold slab_mutex. -*/ -static int __meminit drain_cache_node_node (int node) -{ -struct kmem_cache *cachep; -int ret =0 ; - -list_for_each_entry (cachep, &slab_caches, list) { -struct kmem_cache_node *n; - - n =get_node (cachep, node); -if (!n) -continue ; - -drain_freelist (cachep, n,INT_MAX ); - -if (!list_empty (&n->slabs_full) || - !list_empty (&n->slabs_partial)) { - ret = -EBUSY ; -break ; - } - } -return ret; -} - -static int __meminit slab_memory_callback (struct notifier_block *self, -unsigned long action,void *arg) -{ -struct memory_notify *mnb = arg; -int ret =0 ; -int nid; - - nid = mnb->status_change_nid; -if (nid <0 ) - goto out; - -switch (action) { -case MEM_GOING_ONLINE : -mutex_lock (&slab_mutex); - ret =init_cache_node_node (nid); -mutex_unlock (&slab_mutex); -break ; -case MEM_GOING_OFFLINE : -mutex_lock (&slab_mutex); - ret =drain_cache_node_node (nid); -mutex_unlock (&slab_mutex); -break ; -case MEM_ONLINE : -case MEM_OFFLINE : -case MEM_CANCEL_ONLINE : -case MEM_CANCEL_OFFLINE : -break ; - } -out: -return notifier_from_errno (ret); -} -#endif /* CONFIG_NUMA */ - -/* -* swap the static kmem_cache_node with kmalloced memory -*/ -static void __init init_list (struct kmem_cache *cachep,struct kmem_cache_node *list, -int nodeid) -{ -struct kmem_cache_node *ptr; - - ptr =kmalloc_node (sizeof (struct kmem_cache_node ),GFP_NOWAIT , nodeid); -BUG_ON (!ptr); - -memcpy (ptr, list,sizeof (struct kmem_cache_node )); -/* -* Do not assume that spinlocks can be initialized via memcpy: -*/ -raw_spin_lock_init (&ptr->list_lock); - -MAKE_ALL_LISTS (cachep, ptr, nodeid); - cachep->node[nodeid] = ptr; -} - -/* -* For setting up all the kmem_cache_node for cache whose buffer_size is same as -* size of kmem_cache_node. -*/ -static void __init set_up_node (struct kmem_cache *cachep,int index) -{ -int node; - -for_each_online_node (node) { - cachep->node[node] = &init_kmem_cache_node[index + node]; - cachep->node[node]->next_reap = jiffies + -REAPTIMEOUT_NODE + - ((unsigned long )cachep) %REAPTIMEOUT_NODE ; - } -} - -/* -* Initialisation. Called after the page allocator have been initialised and -* before smp_init(). -*/ -void __init kmem_cache_init (void ) -{ -int i; - - kmem_cache = &kmem_cache_boot; - -if (!IS_ENABLED (CONFIG_NUMA ) ||num_possible_nodes () ==1 ) - use_alien_caches =0 ; - -for (i =0 ; i <NUM_INIT_LISTS ; i++) -kmem_cache_node_init (&init_kmem_cache_node[i]); - -/* -* Fragmentation resistance on low memory - only use bigger -* page orders on machines with more than 32MB of memory if -* not overridden on the command line. -*/ -if (!slab_max_order_set &&totalram_pages () > (32 <<20 ) >>PAGE_SHIFT ) - slab_max_order =SLAB_MAX_ORDER_HI ; - -/* Bootstrap is tricky, because several objects are allocated -* from caches that do not exist yet: -* 1) initialize the kmem_cache cache: it contains the struct -* kmem_cache structures of all caches, except kmem_cache itself: -* kmem_cache is statically allocated. -* Initially an __init data area is used for the head array and the -* kmem_cache_node structures, it's replaced with a kmalloc allocated -* array at the end of the bootstrap. -* 2) Create the first kmalloc cache. -* The struct kmem_cache for the new cache is allocated normally. -* An __init data area is used for the head array. -* 3) Create the remaining kmalloc caches, with minimally sized -* head arrays. -* 4) Replace the __init data head arrays for kmem_cache and the first -* kmalloc cache with kmalloc allocated arrays. -* 5) Replace the __init data for kmem_cache_node for kmem_cache and -* the other cache's with kmalloc allocated memory. -* 6) Resize the head arrays of the kmalloc caches to their final sizes. -*/ - -/* 1) create the kmem_cache */ - -/* -* struct kmem_cache size depends on nr_node_ids & nr_cpu_ids -*/ -create_boot_cache (kmem_cache,"kmem_cache" , - offsetof(struct kmem_cache , node) + - nr_node_ids *sizeof (struct kmem_cache_node *), -SLAB_HWCACHE_ALIGN ,0 ,0 ); -list_add (&kmem_cache->list, &slab_caches); - slab_state =PARTIAL ; - -/* -* Initialize the caches that provide memory for the kmem_cache_node -* structures first. Without this, further allocations will bug. -*/ - kmalloc_caches[KMALLOC_NORMAL ][INDEX_NODE ] =create_kmalloc_cache ( - kmalloc_info[INDEX_NODE ].name[KMALLOC_NORMAL ], - kmalloc_info[INDEX_NODE ].size, -ARCH_KMALLOC_FLAGS ,0 , - kmalloc_info[INDEX_NODE ].size); - slab_state =PARTIAL_NODE ; -setup_kmalloc_cache_index_table (); - -/* 5) Replace the bootstrap kmem_cache_node */ - { -int nid; - -for_each_online_node (nid) { -init_list (kmem_cache, &init_kmem_cache_node[CACHE_CACHE + nid], nid); - -init_list (kmalloc_caches[KMALLOC_NORMAL ][INDEX_NODE ], - &init_kmem_cache_node[SIZE_NODE + nid], nid); - } - } - -create_kmalloc_caches (ARCH_KMALLOC_FLAGS ); -} - -void __init kmem_cache_init_late (void ) -{ -struct kmem_cache *cachep; - -/* 6) resize the head arrays to their final sizes */ -mutex_lock (&slab_mutex); -list_for_each_entry (cachep, &slab_caches, list) -if (enable_cpucache (cachep,GFP_NOWAIT )) -BUG (); -mutex_unlock (&slab_mutex); - -/* Done! */ - slab_state =FULL ; - -#ifdef CONFIG_NUMA -/* -* Register a memory hotplug callback that initializes and frees -* node. -*/ -hotplug_memory_notifier (slab_memory_callback,SLAB_CALLBACK_PRI ); -#endif - -/* -* The reap timers are started later, with a module init call: That part -* of the kernel is not yet operational. -*/ -} - -static int __init cpucache_init (void ) -{ -int ret; - -/* -* Register the timers that return unneeded pages to the page allocator -*/ - ret =cpuhp_setup_state (CPUHP_AP_ONLINE_DYN ,"SLAB online" , - slab_online_cpu, slab_offline_cpu); -WARN_ON (ret <0 ); - -return 0 ; -} -__initcall (cpucache_init); - -static noinline void -slab_out_of_memory (struct kmem_cache *cachep,gfp_t gfpflags,int nodeid) -{ -#if DEBUG -struct kmem_cache_node *n; -unsigned long flags; -int node; - static DEFINE_RATELIMIT_STATE(slab_oom_rs, DEFAULT_RATELIMIT_INTERVAL, - DEFAULT_RATELIMIT_BURST); - -if ((gfpflags & __GFP_NOWARN) || !__ratelimit (&slab_oom_rs)) -return ; - -pr_warn ("SLAB: Unable to allocate memory on node %d, gfp=%#x(%pGg)\n" , - nodeid, gfpflags, &gfpflags); -pr_warn (" cache: %s, object size: %d, order: %d\n" , - cachep->name, cachep->size, cachep->gfporder); - -for_each_kmem_cache_node (cachep, node, n) { -unsigned long total_slabs, free_slabs, free_objs; - -raw_spin_lock_irqsave (&n->list_lock, flags); - total_slabs = n->total_slabs; - free_slabs = n->free_slabs; - free_objs = n->free_objects; -raw_spin_unlock_irqrestore (&n->list_lock, flags); - -pr_warn (" node %d: slabs: %ld/%ld, objs: %ld/%ld\n" , - node, total_slabs - free_slabs, total_slabs, - (total_slabs * cachep->num) - free_objs, - total_slabs * cachep->num); - } -#endif -} - -/* -* Interface to system's page allocator. No need to hold the -* kmem_cache_node ->list_lock. -* -* If we requested dmaable memory, we will get it. Even if we -* did not request dmaable memory, we might get it, but that -* would be relatively rare and ignorable. -*/ -static struct slab *kmem_getpages (struct kmem_cache *cachep,gfp_t flags, -int nodeid) -{ -struct folio *folio; -struct slab *slab; - - flags |= cachep->allocflags; - - folio = (struct folio *)__alloc_pages_node (nodeid, flags, cachep->gfporder); -if (!folio) { -slab_out_of_memory (cachep, flags, nodeid); -return NULL ; - } - - slab =folio_slab (folio); - -account_slab (slab, cachep->gfporder, cachep, flags); -__folio_set_slab (folio); -/* Make the flag visible before any changes to folio->mapping */ -smp_wmb (); -/* Record if ALLOC_NO_WATERMARKS was set when allocating the slab */ -if (sk_memalloc_socks () &&folio_is_pfmemalloc (folio)) -slab_set_pfmemalloc (slab); - -return slab; -} - -/* -* Interface to system's page release. -*/ -static void kmem_freepages (struct kmem_cache *cachep,struct slab *slab) -{ -int order = cachep->gfporder; -struct folio *folio =slab_folio (slab); - -BUG_ON (!folio_test_slab (folio)); -__slab_clear_pfmemalloc (slab); -page_mapcount_reset (&folio->page); - folio->mapping =NULL ; -/* Make the mapping reset visible before clearing the flag */ -smp_wmb (); -__folio_clear_slab (folio); - -if (current->reclaim_state) - current->reclaim_state->reclaimed_slab +=1 << order; -unaccount_slab (slab, order, cachep); -__free_pages (&folio->page, order); -} - -static void kmem_rcu_free (struct rcu_head *head) -{ -struct kmem_cache *cachep; -struct slab *slab; - - slab = container_of(head, struct slab, rcu_head); - cachep = slab->slab_cache; - -kmem_freepages (cachep, slab); -} - -#if DEBUG -static inline bool is_debug_pagealloc_cache (struct kmem_cache *cachep) -{ -return debug_pagealloc_enabled_static () &&OFF_SLAB (cachep) && - ((cachep->size %PAGE_SIZE ) ==0 ); -} - -#ifdef CONFIG_DEBUG_PAGEALLOC -static void slab_kernel_map (struct kmem_cache *cachep,void *objp,int map) -{ -if (!is_debug_pagealloc_cache (cachep)) -return ; - -__kernel_map_pages (virt_to_page (objp), cachep->size /PAGE_SIZE , map); -} - -#else -static inline void slab_kernel_map (struct kmem_cache *cachep,void *objp, -int map) {} - -#endif - -static void poison_obj (struct kmem_cache *cachep,void *addr,unsigned char val) -{ -int size = cachep->object_size; - addr = &((char *)addr)[obj_offset (cachep)]; - -memset (addr, val, size); - *(unsigned char *)(addr + size -1 ) =POISON_END ; -} - -static void dump_line (char *data,int offset,int limit) -{ -int i; -unsigned char error =0 ; -int bad_count =0 ; - -pr_err ("%03x: " , offset); -for (i =0 ; i < limit; i++) { -if (data[offset + i] !=POISON_FREE ) { - error = data[offset + i]; - bad_count++; - } - } -print_hex_dump (KERN_CONT ,"" ,0 ,16 ,1 , - &data[offset], limit,1 ); - -if (bad_count ==1 ) { - error ^=POISON_FREE ; -if (!(error & (error -1 ))) { -pr_err ("Single bit error detected. Probably bad RAM.\n" ); -#ifdef CONFIG_X86 -pr_err ("Run memtest86+ or a similar memory test tool.\n" ); -#else -pr_err ("Run a memory test tool.\n" ); -#endif - } - } -} -#endif - -#if DEBUG - -static void print_objinfo (struct kmem_cache *cachep,void *objp,int lines) -{ -int i, size; -char *realobj; - -if (cachep->flags &SLAB_RED_ZONE ) { -pr_err ("Redzone: 0x%llx/0x%llx\n" , - *dbg_redzone1 (cachep, objp), - *dbg_redzone2 (cachep, objp)); - } - -if (cachep->flags &SLAB_STORE_USER ) -pr_err ("Last user: (%pSR)\n" , *dbg_userword (cachep, objp)); - realobj = (char *)objp +obj_offset (cachep); - size = cachep->object_size; -for (i =0 ; i < size && lines; i +=16 , lines--) { -int limit; - limit =16 ; -if (i + limit > size) - limit = size - i; -dump_line (realobj, i, limit); - } -} - -static void check_poison_obj (struct kmem_cache *cachep,void *objp) -{ -char *realobj; -int size, i; -int lines =0 ; - -if (is_debug_pagealloc_cache (cachep)) -return ; - - realobj = (char *)objp +obj_offset (cachep); - size = cachep->object_size; - -for (i =0 ; i < size; i++) { -char exp =POISON_FREE ; -if (i == size -1 ) - exp =POISON_END ; -if (realobj[i] != exp) { -int limit; -/* Mismatch ! */ -/* Print header */ -if (lines ==0 ) { -pr_err ("Slab corruption (%s): %s start=%px, len=%d\n" , -print_tainted (), cachep->name, - realobj, size); -print_objinfo (cachep, objp,0 ); - } -/* Hexdump the affected line */ - i = (i /16 ) *16 ; - limit =16 ; -if (i + limit > size) - limit = size - i; -dump_line (realobj, i, limit); - i +=16 ; - lines++; -/* Limit to 5 lines */ -if (lines >5 ) -break ; - } - } -if (lines !=0 ) { -/* Print some data about the neighboring objects, if they -* exist: -*/ -struct slab *slab =virt_to_slab (objp); -unsigned int objnr; - - objnr =obj_to_index (cachep, slab, objp); -if (objnr) { - objp =index_to_obj (cachep, slab, objnr -1 ); - realobj = (char *)objp +obj_offset (cachep); -pr_err ("Prev obj: start=%px, len=%d\n" , realobj, size); -print_objinfo (cachep, objp,2 ); - } -if (objnr +1 < cachep->num) { - objp =index_to_obj (cachep, slab, objnr +1 ); - realobj = (char *)objp +obj_offset (cachep); -pr_err ("Next obj: start=%px, len=%d\n" , realobj, size); -print_objinfo (cachep, objp,2 ); - } - } -} -#endif - -#if DEBUG -static void slab_destroy_debugcheck (struct kmem_cache *cachep, -struct slab *slab) -{ -int i; - -if (OBJFREELIST_SLAB (cachep) && cachep->flags &SLAB_POISON ) { -poison_obj (cachep, slab->freelist -obj_offset (cachep), -POISON_FREE ); - } - -for (i =0 ; i < cachep->num; i++) { -void *objp =index_to_obj (cachep, slab, i); - -if (cachep->flags &SLAB_POISON ) { -check_poison_obj (cachep, objp); -slab_kernel_map (cachep, objp,1 ); - } -if (cachep->flags &SLAB_RED_ZONE ) { -if (*dbg_redzone1 (cachep, objp) !=RED_INACTIVE ) -slab_error (cachep,"start of a freed object was overwritten" ); -if (*dbg_redzone2 (cachep, objp) !=RED_INACTIVE ) -slab_error (cachep,"end of a freed object was overwritten" ); - } - } -} -#else -static void slab_destroy_debugcheck (struct kmem_cache *cachep, -struct slab *slab) -{ -} -#endif - -/** -* slab_destroy - destroy and release all objects in a slab -* @cachep: cache pointer being destroyed -* @slab: slab being destroyed -* -* Destroy all the objs in a slab, and release the mem back to the system. -* Before calling the slab must have been unlinked from the cache. The -* kmem_cache_node ->list_lock is not held/needed. -*/ -static void slab_destroy (struct kmem_cache *cachep,struct slab *slab) -{ -void *freelist; - - freelist = slab->freelist; -slab_destroy_debugcheck (cachep, slab); -if (unlikely (cachep->flags &SLAB_TYPESAFE_BY_RCU )) -call_rcu (&slab->rcu_head, kmem_rcu_free); -else -kmem_freepages (cachep, slab); - -/* -* From now on, we don't use freelist -* although actual page can be freed in rcu context -*/ -if (OFF_SLAB (cachep)) -kfree (freelist); -} - -/* -* Update the size of the caches before calling slabs_destroy as it may -* recursively call kfree. -*/ -static void slabs_destroy (struct kmem_cache *cachep,struct list_head *list) -{ -struct slab *slab, *n; - -list_for_each_entry_safe (slab, n, list, slab_list) { -list_del (&slab->slab_list); -slab_destroy (cachep, slab); - } -} - -/** -* calculate_slab_order - calculate size (page order) of slabs -* @cachep: pointer to the cache that is being created -* @size: size of objects to be created in this cache. -* @flags: slab allocation flags -* -* Also calculates the number of objects per slab. -* -* This could be made much more intelligent. For now, try to avoid using -* high order pages for slabs. When the gfp() functions are more friendly -* towards high-order requests, this should be changed. -* -* Return: number of left-over bytes in a slab -*/ -static size_t calculate_slab_order (struct kmem_cache *cachep, -size_t size,slab_flags_t flags) -{ -size_t left_over =0 ; -int gfporder; - -for (gfporder =0 ; gfporder <=KMALLOC_MAX_ORDER ; gfporder++) { -unsigned int num; -size_t remainder; - - num =cache_estimate (gfporder, size, flags, &remainder); -if (!num) -continue ; - -/* Can't handle number of objects more than SLAB_OBJ_MAX_NUM */ -if (num >SLAB_OBJ_MAX_NUM ) -break ; - -if (flags &CFLGS_OFF_SLAB ) { -struct kmem_cache *freelist_cache; -size_t freelist_size; -size_t freelist_cache_size; - - freelist_size = num *sizeof (freelist_idx_t); -if (freelist_size >KMALLOC_MAX_CACHE_SIZE ) { - freelist_cache_size =PAGE_SIZE <<get_order (freelist_size); - }else { - freelist_cache =kmalloc_slab (freelist_size,0u ); -if (!freelist_cache) -continue ; - freelist_cache_size = freelist_cache->size; - -/* -* Needed to avoid possible looping condition -* in cache_grow_begin() -*/ -if (OFF_SLAB (freelist_cache)) -continue ; - } - -/* check if off slab has enough benefit */ -if (freelist_cache_size > cachep->size /2 ) -continue ; - } - -/* Found something acceptable - save it away */ - cachep->num = num; - cachep->gfporder = gfporder; - left_over = remainder; - -/* -* A VFS-reclaimable slab tends to have most allocations -* as GFP_NOFS and we really don't want to have to be allocating -* higher-order pages when we are unable to shrink dcache. -*/ -if (flags &SLAB_RECLAIM_ACCOUNT ) -break ; - -/* -* Large number of objects is good, but very large slabs are -* currently bad for the gfp()s. -*/ -if (gfporder >= slab_max_order) -break ; - -/* -* Acceptable internal fragmentation? -*/ -if (left_over *8 <= (PAGE_SIZE << gfporder)) -break ; - } -return left_over; -} - -static struct array_cache __percpu *alloc_kmem_cache_cpus ( -struct kmem_cache *cachep,int entries,int batchcount) -{ -int cpu; -size_t size; -struct array_cache __percpu *cpu_cache; - - size =sizeof (void *) * entries +sizeof (struct array_cache ); - cpu_cache =__alloc_percpu (size,sizeof (void *)); - -if (!cpu_cache) -return NULL ; - -for_each_possible_cpu (cpu) { -init_arraycache (per_cpu_ptr (cpu_cache, cpu), - entries, batchcount); - } - -return cpu_cache; -} - -static int __ref setup_cpu_cache (struct kmem_cache *cachep,gfp_t gfp) -{ -if (slab_state >=FULL ) -return enable_cpucache (cachep, gfp); - - cachep->cpu_cache =alloc_kmem_cache_cpus (cachep,1 ,1 ); -if (!cachep->cpu_cache) -return 1 ; - -if (slab_state ==DOWN ) { -/* Creation of first cache (kmem_cache). */ -set_up_node (kmem_cache,CACHE_CACHE ); - }else if (slab_state ==PARTIAL ) { -/* For kmem_cache_node */ -set_up_node (cachep,SIZE_NODE ); - }else { -int node; - -for_each_online_node (node) { - cachep->node[node] =kmalloc_node ( -sizeof (struct kmem_cache_node ), gfp, node); -BUG_ON (!cachep->node[node]); -kmem_cache_node_init (cachep->node[node]); - } - } - - cachep->node[numa_mem_id ()]->next_reap = - jiffies +REAPTIMEOUT_NODE + - ((unsigned long )cachep) %REAPTIMEOUT_NODE ; - -cpu_cache_get (cachep)->avail =0 ; -cpu_cache_get (cachep)->limit =BOOT_CPUCACHE_ENTRIES ; -cpu_cache_get (cachep)->batchcount =1 ; -cpu_cache_get (cachep)->touched =0 ; - cachep->batchcount =1 ; - cachep->limit =BOOT_CPUCACHE_ENTRIES ; -return 0 ; -} - -slab_flags_t kmem_cache_flags (unsigned int object_size, -slab_flags_t flags,const char *name) -{ -return flags; -} - -struct kmem_cache * -__kmem_cache_alias (const char *name,unsigned int size,unsigned int align, -slab_flags_t flags,void (*ctor)(void *)) -{ -struct kmem_cache *cachep; - - cachep =find_mergeable (size, align, flags, name, ctor); -if (cachep) { - cachep->refcount++; - -/* -* Adjust the object sizes so that we clear -* the complete object on kzalloc. -*/ - cachep->object_size =max_t (int, cachep->object_size, size); - } -return cachep; -} - -static bool set_objfreelist_slab_cache (struct kmem_cache *cachep, -size_t size,slab_flags_t flags) -{ -size_t left; - - cachep->num =0 ; - -/* -* If slab auto-initialization on free is enabled, store the freelist -* off-slab, so that its contents don't end up in one of the allocated -* objects. -*/ -if (unlikely (slab_want_init_on_free (cachep))) -return false; - -if (cachep->ctor || flags &SLAB_TYPESAFE_BY_RCU ) -return false; - - left =calculate_slab_order (cachep, size, - flags |CFLGS_OBJFREELIST_SLAB ); -if (!cachep->num) -return false; - -if (cachep->num *sizeof (freelist_idx_t) > cachep->object_size) -return false; - - cachep->colour = left / cachep->colour_off; - -return true; -} - -static bool set_off_slab_cache (struct kmem_cache *cachep, -size_t size,slab_flags_t flags) -{ -size_t left; - - cachep->num =0 ; - -/* -* Always use on-slab management when SLAB_NOLEAKTRACE -* to avoid recursive calls into kmemleak. -*/ -if (flags &SLAB_NOLEAKTRACE ) -return false; - -/* -* Size is large, assume best to place the slab management obj -* off-slab (should allow better packing of objs). -*/ - left =calculate_slab_order (cachep, size, flags |CFLGS_OFF_SLAB ); -if (!cachep->num) -return false; - -/* -* If the slab has been placed off-slab, and we have enough space then -* move it on-slab. This is at the expense of any extra colouring. -*/ -if (left >= cachep->num *sizeof (freelist_idx_t)) -return false; - - cachep->colour = left / cachep->colour_off; - -return true; -} - -static bool set_on_slab_cache (struct kmem_cache *cachep, -size_t size,slab_flags_t flags) -{ -size_t left; - - cachep->num =0 ; - - left =calculate_slab_order (cachep, size, flags); -if (!cachep->num) -return false; - - cachep->colour = left / cachep->colour_off; - -return true; -} - -/** -* __kmem_cache_create - Create a cache. -* @cachep: cache management descriptor -* @flags: SLAB flags -* -* Returns a ptr to the cache on success, NULL on failure. -* Cannot be called within an int, but can be interrupted. -* The @ctor is run when new pages are allocated by the cache. -* -* The flags are -* -* %SLAB_POISON - Poison the slab with a known test pattern (a5a5a5a5) -* to catch references to uninitialised memory. -* -* %SLAB_RED_ZONE - Insert `Red' zones around the allocated memory to check -* for buffer overruns. -* -* %SLAB_HWCACHE_ALIGN - Align the objects in this cache to a hardware -* cacheline. This can be beneficial if you're counting cycles as closely -* as davem. -* -* Return: a pointer to the created cache or %NULL in case of error -*/ -int __kmem_cache_create (struct kmem_cache *cachep,slab_flags_t flags) -{ -size_t ralign =BYTES_PER_WORD ; -gfp_t gfp; -int err; -unsigned int size = cachep->size; - -#if DEBUG -#if FORCED_DEBUG -/* -* Enable redzoning and last user accounting, except for caches with -* large objects, if the increased size would increase the object size -* above the next power of two: caches with object sizes just above a -* power of two have a significant amount of internal fragmentation. -*/ -if (size <4096 ||fls (size -1 ) ==fls (size-1 +REDZONE_ALIGN + -2 *sizeof (unsigned long long ))) - flags |=SLAB_RED_ZONE |SLAB_STORE_USER ; -if (!(flags &SLAB_TYPESAFE_BY_RCU )) - flags |=SLAB_POISON ; -#endif -#endif - -/* -* Check that size is in terms of words. This is needed to avoid -* unaligned accesses for some archs when redzoning is used, and makes -* sure any on-slab bufctl's are also correctly aligned. -*/ - size =ALIGN (size,BYTES_PER_WORD ); - -if (flags &SLAB_RED_ZONE ) { - ralign =REDZONE_ALIGN ; -/* If redzoning, ensure that the second redzone is suitably -* aligned, by adjusting the object size accordingly. */ - size =ALIGN (size,REDZONE_ALIGN ); - } - -/* 3) caller mandated alignment */ -if (ralign < cachep->align) { - ralign = cachep->align; - } -/* disable debug if necessary */ -if (ralign > __alignof__(unsigned long long )) - flags &= ~(SLAB_RED_ZONE |SLAB_STORE_USER ); -/* -* 4) Store it. -*/ - cachep->align = ralign; - cachep->colour_off =cache_line_size (); -/* Offset must be a multiple of the alignment. */ -if (cachep->colour_off < cachep->align) - cachep->colour_off = cachep->align; - -if (slab_is_available ()) - gfp =GFP_KERNEL ; -else - gfp =GFP_NOWAIT ; - -#if DEBUG - -/* -* Both debugging options require word-alignment which is calculated -* into align above. -*/ -if (flags &SLAB_RED_ZONE ) { -/* add space for red zone words */ - cachep->obj_offset +=sizeof (unsigned long long ); - size +=2 *sizeof (unsigned long long ); - } -if (flags &SLAB_STORE_USER ) { -/* user store requires one word storage behind the end of -* the real object. But if the second red zone needs to be -* aligned to 64 bits, we must allow that much space. -*/ -if (flags &SLAB_RED_ZONE ) - size +=REDZONE_ALIGN ; -else - size +=BYTES_PER_WORD ; - } -#endif - -kasan_cache_create (cachep, &size, &flags); - - size =ALIGN (size, cachep->align); -/* -* We should restrict the number of objects in a slab to implement -* byte sized index. Refer comment on SLAB_OBJ_MIN_SIZE definition. -*/ -if (FREELIST_BYTE_INDEX && size <SLAB_OBJ_MIN_SIZE ) - size =ALIGN (SLAB_OBJ_MIN_SIZE , cachep->align); - -#if DEBUG -/* -* To activate debug pagealloc, off-slab management is necessary -* requirement. In early phase of initialization, small sized slab -* doesn't get initialized so it would not be possible. So, we need -* to check size >= 256. It guarantees that all necessary small -* sized slab is initialized in current slab initialization sequence. -*/ -if (debug_pagealloc_enabled_static () && (flags &SLAB_POISON ) && - size >=256 && cachep->object_size >cache_line_size ()) { -if (size <PAGE_SIZE || size %PAGE_SIZE ==0 ) { -size_t tmp_size =ALIGN (size,PAGE_SIZE ); - -if (set_off_slab_cache (cachep, tmp_size, flags)) { - flags |=CFLGS_OFF_SLAB ; - cachep->obj_offset += tmp_size - size; - size = tmp_size; - goto done; - } - } - } -#endif - -if (set_objfreelist_slab_cache (cachep, size, flags)) { - flags |=CFLGS_OBJFREELIST_SLAB ; - goto done; - } - -if (set_off_slab_cache (cachep, size, flags)) { - flags |=CFLGS_OFF_SLAB ; - goto done; - } - -if (set_on_slab_cache (cachep, size, flags)) - goto done; - -return -E2BIG ; - -done: - cachep->freelist_size = cachep->num *sizeof (freelist_idx_t); - cachep->flags = flags; - cachep->allocflags = __GFP_COMP; -if (flags &SLAB_CACHE_DMA ) - cachep->allocflags |=GFP_DMA ; -if (flags &SLAB_CACHE_DMA32 ) - cachep->allocflags |=GFP_DMA32 ; -if (flags &SLAB_RECLAIM_ACCOUNT ) - cachep->allocflags |= __GFP_RECLAIMABLE; - cachep->size = size; - cachep->reciprocal_buffer_size =reciprocal_value (size); - -#if DEBUG -/* -* If we're going to use the generic kernel_map_pages() -* poisoning, then it's going to smash the contents of -* the redzone and userword anyhow, so switch them off. -*/ -if (IS_ENABLED (CONFIG_PAGE_POISONING ) && - (cachep->flags &SLAB_POISON ) && -is_debug_pagealloc_cache (cachep)) - cachep->flags &= ~(SLAB_RED_ZONE |SLAB_STORE_USER ); -#endif - - err =setup_cpu_cache (cachep, gfp); -if (err) { -__kmem_cache_release (cachep); -return err; - } - -return 0 ; -} - -#if DEBUG -static void check_irq_off (void ) -{ -BUG_ON (!irqs_disabled ()); -} - -static void check_irq_on (void ) -{ -BUG_ON (irqs_disabled ()); -} - -static void check_mutex_acquired (void ) -{ -BUG_ON (!mutex_is_locked (&slab_mutex)); -} - -static void check_spinlock_acquired (struct kmem_cache *cachep) -{ -#ifdef CONFIG_SMP -check_irq_off (); -assert_raw_spin_locked (&get_node (cachep,numa_mem_id ())->list_lock); -#endif -} - -static void check_spinlock_acquired_node (struct kmem_cache *cachep,int node) -{ -#ifdef CONFIG_SMP -check_irq_off (); -assert_raw_spin_locked (&get_node (cachep, node)->list_lock); -#endif -} - -#else -#define check_irq_off () do { } while(0) -#define check_irq_on () do { } while(0) -#define check_mutex_acquired () do { } while(0) -#define check_spinlock_acquired (x) do { } while(0) -#define check_spinlock_acquired_node (x, y) do { } while(0) -#endif - -static void drain_array_locked (struct kmem_cache *cachep,struct array_cache *ac, -int node,bool free_all,struct list_head *list) -{ -int tofree; - -if (!ac || !ac->avail) -return ; - - tofree = free_all ? ac->avail : (ac->limit +4 ) /5 ; -if (tofree > ac->avail) - tofree = (ac->avail +1 ) /2 ; - -free_block (cachep, ac->entry, tofree, node, list); - ac->avail -= tofree; -memmove (ac->entry, &(ac->entry[tofree]),sizeof (void *) * ac->avail); -} - -static void do_drain (void *arg) -{ -struct kmem_cache *cachep = arg; -struct array_cache *ac; -int node =numa_mem_id (); -struct kmem_cache_node *n; -LIST_HEAD (list); - -check_irq_off (); - ac =cpu_cache_get (cachep); - n =get_node (cachep, node); -raw_spin_lock (&n->list_lock); -free_block (cachep, ac->entry, ac->avail, node, &list); -raw_spin_unlock (&n->list_lock); - ac->avail =0 ; -slabs_destroy (cachep, &list); -} - -static void drain_cpu_caches (struct kmem_cache *cachep) -{ -struct kmem_cache_node *n; -int node; -LIST_HEAD (list); - -on_each_cpu (do_drain, cachep,1 ); -check_irq_on (); -for_each_kmem_cache_node (cachep, node, n) -if (n->alien) -drain_alien_cache (cachep, n->alien); - -for_each_kmem_cache_node (cachep, node, n) { -raw_spin_lock_irq (&n->list_lock); -drain_array_locked (cachep, n->shared, node, true, &list); -raw_spin_unlock_irq (&n->list_lock); - -slabs_destroy (cachep, &list); - } -} - -/* -* Remove slabs from the list of free slabs. -* Specify the number of slabs to drain in tofree. -* -* Returns the actual number of slabs released. -*/ -static int drain_freelist (struct kmem_cache *cache, -struct kmem_cache_node *n,int tofree) -{ -struct list_head *p; -int nr_freed; -struct slab *slab; - - nr_freed =0 ; -while (nr_freed < tofree && !list_empty (&n->slabs_free)) { - -raw_spin_lock_irq (&n->list_lock); - p = n->slabs_free.prev; -if (p == &n->slabs_free) { -raw_spin_unlock_irq (&n->list_lock); - goto out; - } - - slab = list_entry(p, struct slab, slab_list); -list_del (&slab->slab_list); - n->free_slabs--; - n->total_slabs--; -/* -* Safe to drop the lock. The slab is no longer linked -* to the cache. -*/ - n->free_objects -= cache->num; -raw_spin_unlock_irq (&n->list_lock); -slab_destroy (cache, slab); - nr_freed++;Lines of this file are not shown. View the raw message.
The rest of this diff is not shown. View the raw message.
2.40.0
Part of the diff is not shown here. View the raw message.