2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2006-12-13 01:34:23 -07:00
|
|
|
* Written by Mark Hemment, 1996 (markhe@nextd.demon.co.uk).
|
|
|
|
*
|
2008-07-04 10:59:22 -06:00
|
|
|
* (C) SGI 2006, Christoph Lameter
|
2006-12-13 01:34:23 -07:00
|
|
|
* Cleaned up and restructured to ease the addition of alternative
|
|
|
|
* implementations of SLAB allocators.
|
2013-09-04 10:35:34 -06:00
|
|
|
* (C) Linux Foundation 2008-2013
|
|
|
|
* Unified interface for all slab allocators
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef _LINUX_SLAB_H
|
|
|
|
#define _LINUX_SLAB_H
|
|
|
|
|
2006-12-06 21:33:22 -07:00
|
|
|
#include <linux/gfp.h>
|
|
|
|
#include <linux/types.h>
|
2012-12-18 15:22:50 -07:00
|
|
|
#include <linux/workqueue.h>
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-12-13 01:34:23 -07:00
|
|
|
/*
|
|
|
|
* Flags to pass to kmem_cache_create().
|
2015-04-14 16:44:28 -06:00
|
|
|
* The ones marked DEBUG are only valid if CONFIG_DEBUG_SLAB is set.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2016-03-15 15:55:06 -06:00
|
|
|
#define SLAB_CONSISTENCY_CHECKS 0x00000100UL /* DEBUG: Perform (expensive) checks on alloc/free */
|
2006-12-13 01:34:24 -07:00
|
|
|
#define SLAB_RED_ZONE 0x00000400UL /* DEBUG: Red zone objs in a cache */
|
|
|
|
#define SLAB_POISON 0x00000800UL /* DEBUG: Poison objects */
|
|
|
|
#define SLAB_HWCACHE_ALIGN 0x00002000UL /* Align objs on cache lines */
|
2006-12-13 01:34:23 -07:00
|
|
|
#define SLAB_CACHE_DMA 0x00004000UL /* Use GFP_DMA memory */
|
|
|
|
#define SLAB_STORE_USER 0x00010000UL /* DEBUG: Store the last owner for bug hunting */
|
|
|
|
#define SLAB_PANIC 0x00040000UL /* Panic if kmem_cache_create() fails */
|
2008-11-13 11:40:12 -07:00
|
|
|
/*
|
|
|
|
* SLAB_DESTROY_BY_RCU - **WARNING** READ THIS!
|
|
|
|
*
|
|
|
|
* This delays freeing the SLAB page by a grace period, it does _NOT_
|
|
|
|
* delay object freeing. This means that if you do kmem_cache_free()
|
|
|
|
* that memory location is free to be reused at any time. Thus it may
|
|
|
|
* be possible to see another object there in the same RCU grace period.
|
|
|
|
*
|
|
|
|
* This feature only ensures the memory location backing the object
|
|
|
|
* stays valid, the trick to using this is relying on an independent
|
|
|
|
* object validation pass. Something like:
|
|
|
|
*
|
|
|
|
* rcu_read_lock()
|
|
|
|
* again:
|
|
|
|
* obj = lockless_lookup(key);
|
|
|
|
* if (obj) {
|
|
|
|
* if (!try_get_ref(obj)) // might fail for free objects
|
|
|
|
* goto again;
|
|
|
|
*
|
|
|
|
* if (obj->key != key) { // not the object we expected
|
|
|
|
* put_ref(obj);
|
|
|
|
* goto again;
|
|
|
|
* }
|
|
|
|
* }
|
|
|
|
* rcu_read_unlock();
|
|
|
|
*
|
2013-10-23 19:07:42 -06:00
|
|
|
* This is useful if we need to approach a kernel structure obliquely,
|
|
|
|
* from its address obtained without the usual locking. We can lock
|
|
|
|
* the structure to stabilize it and check it's still at the given address,
|
|
|
|
* only if we can be sure that the memory has not been meanwhile reused
|
|
|
|
* for some other kind of object (which our subsystem's lock might corrupt).
|
|
|
|
*
|
|
|
|
* rcu_read_lock before reading the address, then rcu_read_unlock after
|
|
|
|
* taking the spinlock within the structure expected at that address.
|
2008-11-13 11:40:12 -07:00
|
|
|
*/
|
2006-12-13 01:34:23 -07:00
|
|
|
#define SLAB_DESTROY_BY_RCU 0x00080000UL /* Defer freeing slabs to RCU */
|
[PATCH] cpuset memory spread slab cache implementation
Provide the slab cache infrastructure to support cpuset memory spreading.
See the previous patches, cpuset_mem_spread, for an explanation of cpuset
memory spreading.
This patch provides a slab cache SLAB_MEM_SPREAD flag. If set in the
kmem_cache_create() call defining a slab cache, then any task marked with the
process state flag PF_MEMSPREAD will spread memory page allocations for that
cache over all the allowed nodes, instead of preferring the local (faulting)
node.
On systems not configured with CONFIG_NUMA, this results in no change to the
page allocation code path for slab caches.
On systems with cpusets configured in the kernel, but the "memory_spread"
cpuset option not enabled for the current tasks cpuset, this adds a call to a
cpuset routine and failed bit test of the processor state flag PF_SPREAD_SLAB.
For tasks so marked, a second inline test is done for the slab cache flag
SLAB_MEM_SPREAD, and if that is set and if the allocation is not
in_interrupt(), this adds a call to to a cpuset routine that computes which of
the tasks mems_allowed nodes should be preferred for this allocation.
==> This patch adds another hook into the performance critical
code path to allocating objects from the slab cache, in the
____cache_alloc() chunk, below. The next patch optimizes this
hook, reducing the impact of the combined mempolicy plus memory
spreading hooks on this critical code path to a single check
against the tasks task_struct flags word.
This patch provides the generic slab flags and logic needed to apply memory
spreading to a particular slab.
A subsequent patch will mark a few specific slab caches for this placement
policy.
Signed-off-by: Paul Jackson <pj@sgi.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-24 04:16:07 -07:00
|
|
|
#define SLAB_MEM_SPREAD 0x00100000UL /* Spread some memory over cpuset */
|
2007-05-06 15:49:36 -06:00
|
|
|
#define SLAB_TRACE 0x00200000UL /* Trace allocations and frees */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-04-30 01:54:59 -06:00
|
|
|
/* Flag to prevent checks on free */
|
|
|
|
#ifdef CONFIG_DEBUG_OBJECTS
|
|
|
|
# define SLAB_DEBUG_OBJECTS 0x00400000UL
|
|
|
|
#else
|
|
|
|
# define SLAB_DEBUG_OBJECTS 0x00000000UL
|
|
|
|
#endif
|
|
|
|
|
2009-06-11 06:22:40 -06:00
|
|
|
#define SLAB_NOLEAKTRACE 0x00800000UL /* Avoid kmemleak tracing */
|
|
|
|
|
kmemcheck: add mm functions
With kmemcheck enabled, the slab allocator needs to do this:
1. Tell kmemcheck to allocate the shadow memory which stores the status of
each byte in the allocation proper, e.g. whether it is initialized or
uninitialized.
2. Tell kmemcheck which parts of memory that should be marked uninitialized.
There are actually a few more states, such as "not yet allocated" and
"recently freed".
If a slab cache is set up using the SLAB_NOTRACK flag, it will never return
memory that can take page faults because of kmemcheck.
If a slab cache is NOT set up using the SLAB_NOTRACK flag, callers can still
request memory with the __GFP_NOTRACK flag. This does not prevent the page
faults from occuring, however, but marks the object in question as being
initialized so that no warnings will ever be produced for this object.
In addition to (and in contrast to) __GFP_NOTRACK, the
__GFP_NOTRACK_FALSE_POSITIVE flag indicates that the allocation should
not be tracked _because_ it would produce a false positive. Their values
are identical, but need not be so in the future (for example, we could now
enable/disable false positives with a config option).
Parts of this patch were contributed by Pekka Enberg but merged for
atomicity.
Signed-off-by: Vegard Nossum <vegard.nossum@gmail.com>
Signed-off-by: Pekka Enberg <penberg@cs.helsinki.fi>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
[rebased for mainline inclusion]
Signed-off-by: Vegard Nossum <vegard.nossum@gmail.com>
2008-05-31 07:56:17 -06:00
|
|
|
/* Don't track use of uninitialized memory */
|
|
|
|
#ifdef CONFIG_KMEMCHECK
|
|
|
|
# define SLAB_NOTRACK 0x01000000UL
|
|
|
|
#else
|
|
|
|
# define SLAB_NOTRACK 0x00000000UL
|
|
|
|
#endif
|
2010-02-25 23:36:12 -07:00
|
|
|
#ifdef CONFIG_FAILSLAB
|
|
|
|
# define SLAB_FAILSLAB 0x02000000UL /* Fault injection mark */
|
|
|
|
#else
|
|
|
|
# define SLAB_FAILSLAB 0x00000000UL
|
|
|
|
#endif
|
2016-01-20 16:02:32 -07:00
|
|
|
#if defined(CONFIG_MEMCG) && !defined(CONFIG_SLOB)
|
2016-01-14 16:18:15 -07:00
|
|
|
# define SLAB_ACCOUNT 0x04000000UL /* Account to memcg */
|
|
|
|
#else
|
|
|
|
# define SLAB_ACCOUNT 0x00000000UL
|
|
|
|
#endif
|
kmemcheck: add mm functions
With kmemcheck enabled, the slab allocator needs to do this:
1. Tell kmemcheck to allocate the shadow memory which stores the status of
each byte in the allocation proper, e.g. whether it is initialized or
uninitialized.
2. Tell kmemcheck which parts of memory that should be marked uninitialized.
There are actually a few more states, such as "not yet allocated" and
"recently freed".
If a slab cache is set up using the SLAB_NOTRACK flag, it will never return
memory that can take page faults because of kmemcheck.
If a slab cache is NOT set up using the SLAB_NOTRACK flag, callers can still
request memory with the __GFP_NOTRACK flag. This does not prevent the page
faults from occuring, however, but marks the object in question as being
initialized so that no warnings will ever be produced for this object.
In addition to (and in contrast to) __GFP_NOTRACK, the
__GFP_NOTRACK_FALSE_POSITIVE flag indicates that the allocation should
not be tracked _because_ it would produce a false positive. Their values
are identical, but need not be so in the future (for example, we could now
enable/disable false positives with a config option).
Parts of this patch were contributed by Pekka Enberg but merged for
atomicity.
Signed-off-by: Vegard Nossum <vegard.nossum@gmail.com>
Signed-off-by: Pekka Enberg <penberg@cs.helsinki.fi>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
[rebased for mainline inclusion]
Signed-off-by: Vegard Nossum <vegard.nossum@gmail.com>
2008-05-31 07:56:17 -06:00
|
|
|
|
2016-03-25 15:21:59 -06:00
|
|
|
#ifdef CONFIG_KASAN
|
|
|
|
#define SLAB_KASAN 0x08000000UL
|
|
|
|
#else
|
|
|
|
#define SLAB_KASAN 0x00000000UL
|
|
|
|
#endif
|
|
|
|
|
2007-10-16 02:25:52 -06:00
|
|
|
/* The following flags affect the page allocator grouping pages by mobility */
|
|
|
|
#define SLAB_RECLAIM_ACCOUNT 0x00020000UL /* Objects are reclaimable */
|
|
|
|
#define SLAB_TEMPORARY SLAB_RECLAIM_ACCOUNT /* Objects are short-lived */
|
2007-07-17 05:03:22 -06:00
|
|
|
/*
|
|
|
|
* ZERO_SIZE_PTR will be returned for zero sized kmalloc requests.
|
|
|
|
*
|
|
|
|
* Dereferencing ZERO_SIZE_PTR will lead to a distinct access fault.
|
|
|
|
*
|
|
|
|
* ZERO_SIZE_PTR can be passed to kfree though in the same way that NULL can.
|
|
|
|
* Both make kfree a no-op.
|
|
|
|
*/
|
|
|
|
#define ZERO_SIZE_PTR ((void *)16)
|
|
|
|
|
2007-07-20 13:13:20 -06:00
|
|
|
#define ZERO_OR_NULL_PTR(x) ((unsigned long)(x) <= \
|
2007-07-17 05:03:22 -06:00
|
|
|
(unsigned long)ZERO_SIZE_PTR)
|
|
|
|
|
2013-09-04 10:35:34 -06:00
|
|
|
#include <linux/kmemleak.h>
|
2015-02-13 15:39:42 -07:00
|
|
|
#include <linux/kasan.h>
|
2012-06-13 09:24:57 -06:00
|
|
|
|
2012-12-18 15:22:34 -07:00
|
|
|
struct mem_cgroup;
|
2006-12-13 01:34:23 -07:00
|
|
|
/*
|
|
|
|
* struct kmem_cache related prototypes
|
|
|
|
*/
|
|
|
|
void __init kmem_cache_init(void);
|
2015-11-05 19:44:59 -07:00
|
|
|
bool slab_is_available(void);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-12-13 01:34:23 -07:00
|
|
|
struct kmem_cache *kmem_cache_create(const char *, size_t, size_t,
|
2006-12-06 21:32:59 -07:00
|
|
|
unsigned long,
|
2008-07-25 20:45:34 -06:00
|
|
|
void (*)(void *));
|
2006-12-13 01:34:23 -07:00
|
|
|
void kmem_cache_destroy(struct kmem_cache *);
|
|
|
|
int kmem_cache_shrink(struct kmem_cache *);
|
2015-02-12 15:59:32 -07:00
|
|
|
|
|
|
|
void memcg_create_kmem_cache(struct mem_cgroup *, struct kmem_cache *);
|
|
|
|
void memcg_deactivate_kmem_caches(struct mem_cgroup *);
|
|
|
|
void memcg_destroy_kmem_caches(struct mem_cgroup *);
|
2006-12-13 01:34:23 -07:00
|
|
|
|
2007-05-06 15:49:57 -06:00
|
|
|
/*
|
|
|
|
* Please use this macro to create slab caches. Simply specify the
|
|
|
|
* name of the structure and maybe some flags that are listed above.
|
|
|
|
*
|
|
|
|
* The alignment of the struct determines object alignment. If you
|
|
|
|
* f.e. add ____cacheline_aligned_in_smp to the struct declaration
|
|
|
|
* then the objects will be properly aligned in SMP configurations.
|
|
|
|
*/
|
|
|
|
#define KMEM_CACHE(__struct, __flags) kmem_cache_create(#__struct,\
|
|
|
|
sizeof(struct __struct), __alignof__(struct __struct),\
|
2007-07-19 19:11:58 -06:00
|
|
|
(__flags), NULL)
|
2007-05-06 15:49:57 -06:00
|
|
|
|
2013-01-10 12:00:53 -07:00
|
|
|
/*
|
|
|
|
* Common kmalloc functions provided by all allocators
|
|
|
|
*/
|
|
|
|
void * __must_check __krealloc(const void *, size_t, gfp_t);
|
|
|
|
void * __must_check krealloc(const void *, size_t, gfp_t);
|
|
|
|
void kfree(const void *);
|
|
|
|
void kzfree(const void *);
|
|
|
|
size_t ksize(const void *);
|
|
|
|
|
2016-06-07 12:05:33 -06:00
|
|
|
#ifdef CONFIG_HAVE_HARDENED_USERCOPY_ALLOCATOR
|
|
|
|
const char *__check_heap_object(const void *ptr, unsigned long n,
|
|
|
|
struct page *page);
|
|
|
|
#else
|
|
|
|
static inline const char *__check_heap_object(const void *ptr,
|
|
|
|
unsigned long n,
|
|
|
|
struct page *page)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2013-02-05 09:36:47 -07:00
|
|
|
/*
|
|
|
|
* Some archs want to perform DMA into kmalloc caches and need a guaranteed
|
|
|
|
* alignment larger than the alignment of a 64-bit integer.
|
|
|
|
* Setting ARCH_KMALLOC_MINALIGN in arch headers allows that.
|
|
|
|
*/
|
|
|
|
#if defined(ARCH_DMA_MINALIGN) && ARCH_DMA_MINALIGN > 8
|
|
|
|
#define ARCH_KMALLOC_MINALIGN ARCH_DMA_MINALIGN
|
|
|
|
#define KMALLOC_MIN_SIZE ARCH_DMA_MINALIGN
|
|
|
|
#define KMALLOC_SHIFT_LOW ilog2(ARCH_DMA_MINALIGN)
|
|
|
|
#else
|
|
|
|
#define ARCH_KMALLOC_MINALIGN __alignof__(unsigned long long)
|
|
|
|
#endif
|
|
|
|
|
slab.h: sprinkle __assume_aligned attributes
The various allocators return aligned memory. Telling the compiler that
allows it to generate better code in many cases, for example when the
return value is immediately passed to memset().
Some code does become larger, but at least we win twice as much as we lose:
$ scripts/bloat-o-meter /tmp/vmlinux vmlinux
add/remove: 0/0 grow/shrink: 13/52 up/down: 995/-2140 (-1145)
An example of the different (and smaller) code can be seen in mm_alloc(). Before:
: 48 8d 78 08 lea 0x8(%rax),%rdi
: 48 89 c1 mov %rax,%rcx
: 48 89 c2 mov %rax,%rdx
: 48 c7 00 00 00 00 00 movq $0x0,(%rax)
: 48 c7 80 48 03 00 00 movq $0x0,0x348(%rax)
: 00 00 00 00
: 31 c0 xor %eax,%eax
: 48 83 e7 f8 and $0xfffffffffffffff8,%rdi
: 48 29 f9 sub %rdi,%rcx
: 81 c1 50 03 00 00 add $0x350,%ecx
: c1 e9 03 shr $0x3,%ecx
: f3 48 ab rep stos %rax,%es:(%rdi)
After:
: 48 89 c2 mov %rax,%rdx
: b9 6a 00 00 00 mov $0x6a,%ecx
: 31 c0 xor %eax,%eax
: 48 89 d7 mov %rdx,%rdi
: f3 48 ab rep stos %rax,%es:(%rdi)
So gcc's strategy is to do two possibly (but not really, of course)
unaligned stores to the first and last word, then do an aligned rep stos
covering the middle part with a little overlap. Maybe arches which do not
allow unaligned stores gain even more.
I don't know if gcc can actually make use of alignments greater than 8 for
anything, so one could probably drop the __assume_xyz_alignment macros and
just use __assume_aligned(8).
The increases in code size are mostly caused by gcc deciding to
opencode strlen() using the check-four-bytes-at-a-time trick when it
knows the buffer is sufficiently aligned (one function grew by 200
bytes). Now it turns out that many of these strlen() calls showing up
were in fact redundant, and they're gone from -next. Applying the two
patches to next-20151001 bloat-o-meter instead says
add/remove: 0/0 grow/shrink: 6/52 up/down: 244/-2140 (-1896)
Signed-off-by: Rasmus Villemoes <linux@rasmusvillemoes.dk>
Acked-by: Christoph Lameter <cl@linux.com>
Cc: David Rientjes <rientjes@google.com>
Cc: Pekka Enberg <penberg@kernel.org>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-11-20 16:56:48 -07:00
|
|
|
/*
|
|
|
|
* Setting ARCH_SLAB_MINALIGN in arch headers allows a different alignment.
|
|
|
|
* Intended for arches that get misalignment faults even for 64 bit integer
|
|
|
|
* aligned buffers.
|
|
|
|
*/
|
|
|
|
#ifndef ARCH_SLAB_MINALIGN
|
|
|
|
#define ARCH_SLAB_MINALIGN __alignof__(unsigned long long)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* kmalloc and friends return ARCH_KMALLOC_MINALIGN aligned
|
|
|
|
* pointers. kmem_cache_alloc and friends return ARCH_SLAB_MINALIGN
|
|
|
|
* aligned pointers.
|
|
|
|
*/
|
|
|
|
#define __assume_kmalloc_alignment __assume_aligned(ARCH_KMALLOC_MINALIGN)
|
|
|
|
#define __assume_slab_alignment __assume_aligned(ARCH_SLAB_MINALIGN)
|
|
|
|
#define __assume_page_alignment __assume_aligned(PAGE_SIZE)
|
|
|
|
|
2007-05-16 23:11:01 -06:00
|
|
|
/*
|
2013-01-10 12:14:19 -07:00
|
|
|
* Kmalloc array related definitions
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef CONFIG_SLAB
|
|
|
|
/*
|
|
|
|
* The largest kmalloc size supported by the SLAB allocators is
|
2007-05-16 23:11:01 -06:00
|
|
|
* 32 megabyte (2^25) or the maximum allocatable page order if that is
|
|
|
|
* less than 32 MB.
|
|
|
|
*
|
|
|
|
* WARNING: Its not easy to increase this value since the allocators have
|
|
|
|
* to do various tricks to work around compiler limitations in order to
|
|
|
|
* ensure proper constant folding.
|
|
|
|
*/
|
2007-06-23 18:16:43 -06:00
|
|
|
#define KMALLOC_SHIFT_HIGH ((MAX_ORDER + PAGE_SHIFT - 1) <= 25 ? \
|
|
|
|
(MAX_ORDER + PAGE_SHIFT - 1) : 25)
|
2013-01-10 12:14:19 -07:00
|
|
|
#define KMALLOC_SHIFT_MAX KMALLOC_SHIFT_HIGH
|
2013-02-05 09:36:47 -07:00
|
|
|
#ifndef KMALLOC_SHIFT_LOW
|
2013-01-10 12:14:19 -07:00
|
|
|
#define KMALLOC_SHIFT_LOW 5
|
2013-02-05 09:36:47 -07:00
|
|
|
#endif
|
2013-06-14 13:55:13 -06:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_SLUB
|
2013-01-10 12:14:19 -07:00
|
|
|
/*
|
2014-01-28 15:24:50 -07:00
|
|
|
* SLUB directly allocates requests fitting in to an order-1 page
|
|
|
|
* (PAGE_SIZE*2). Larger requests are passed to the page allocator.
|
2013-01-10 12:14:19 -07:00
|
|
|
*/
|
|
|
|
#define KMALLOC_SHIFT_HIGH (PAGE_SHIFT + 1)
|
|
|
|
#define KMALLOC_SHIFT_MAX (MAX_ORDER + PAGE_SHIFT)
|
2013-02-05 09:36:47 -07:00
|
|
|
#ifndef KMALLOC_SHIFT_LOW
|
2013-01-10 12:14:19 -07:00
|
|
|
#define KMALLOC_SHIFT_LOW 3
|
|
|
|
#endif
|
2013-02-05 09:36:47 -07:00
|
|
|
#endif
|
2007-05-16 23:11:01 -06:00
|
|
|
|
2013-06-14 13:55:13 -06:00
|
|
|
#ifdef CONFIG_SLOB
|
|
|
|
/*
|
2014-01-28 15:24:50 -07:00
|
|
|
* SLOB passes all requests larger than one page to the page allocator.
|
2013-06-14 13:55:13 -06:00
|
|
|
* No kmalloc array is necessary since objects of different sizes can
|
|
|
|
* be allocated from the same page.
|
|
|
|
*/
|
|
|
|
#define KMALLOC_SHIFT_HIGH PAGE_SHIFT
|
2014-01-28 15:24:50 -07:00
|
|
|
#define KMALLOC_SHIFT_MAX 30
|
2013-06-14 13:55:13 -06:00
|
|
|
#ifndef KMALLOC_SHIFT_LOW
|
|
|
|
#define KMALLOC_SHIFT_LOW 3
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
2013-01-10 12:14:19 -07:00
|
|
|
/* Maximum allocatable size */
|
|
|
|
#define KMALLOC_MAX_SIZE (1UL << KMALLOC_SHIFT_MAX)
|
|
|
|
/* Maximum size for which we actually use a slab cache */
|
|
|
|
#define KMALLOC_MAX_CACHE_SIZE (1UL << KMALLOC_SHIFT_HIGH)
|
|
|
|
/* Maximum order allocatable via the slab allocagtor */
|
|
|
|
#define KMALLOC_MAX_ORDER (KMALLOC_SHIFT_MAX - PAGE_SHIFT)
|
2007-05-16 23:11:01 -06:00
|
|
|
|
2013-01-10 12:14:19 -07:00
|
|
|
/*
|
|
|
|
* Kmalloc subsystem.
|
|
|
|
*/
|
2013-02-05 09:36:47 -07:00
|
|
|
#ifndef KMALLOC_MIN_SIZE
|
2013-01-10 12:14:19 -07:00
|
|
|
#define KMALLOC_MIN_SIZE (1 << KMALLOC_SHIFT_LOW)
|
2013-01-10 12:14:19 -07:00
|
|
|
#endif
|
|
|
|
|
2014-03-12 02:06:19 -06:00
|
|
|
/*
|
|
|
|
* This restriction comes from byte sized index implementation.
|
|
|
|
* Page size is normally 2^12 bytes and, in this case, if we want to use
|
|
|
|
* byte sized index which can represent 2^8 entries, the size of the object
|
|
|
|
* should be equal or greater to 2^12 / 2^8 = 2^4 = 16.
|
|
|
|
* If minimum size of kmalloc is less than 16, we use it as minimum object
|
|
|
|
* size and give up to use byte sized index.
|
|
|
|
*/
|
|
|
|
#define SLAB_OBJ_MIN_SIZE (KMALLOC_MIN_SIZE < 16 ? \
|
|
|
|
(KMALLOC_MIN_SIZE) : 16)
|
|
|
|
|
2013-06-14 13:55:13 -06:00
|
|
|
#ifndef CONFIG_SLOB
|
2013-01-10 12:12:17 -07:00
|
|
|
extern struct kmem_cache *kmalloc_caches[KMALLOC_SHIFT_HIGH + 1];
|
|
|
|
#ifdef CONFIG_ZONE_DMA
|
|
|
|
extern struct kmem_cache *kmalloc_dma_caches[KMALLOC_SHIFT_HIGH + 1];
|
|
|
|
#endif
|
|
|
|
|
2013-01-10 12:14:19 -07:00
|
|
|
/*
|
|
|
|
* Figure out which kmalloc slab an allocation of a certain size
|
|
|
|
* belongs to.
|
|
|
|
* 0 = zero alloc
|
|
|
|
* 1 = 65 .. 96 bytes
|
2015-06-24 17:55:59 -06:00
|
|
|
* 2 = 129 .. 192 bytes
|
|
|
|
* n = 2^(n-1)+1 .. 2^n
|
2013-01-10 12:14:19 -07:00
|
|
|
*/
|
|
|
|
static __always_inline int kmalloc_index(size_t size)
|
|
|
|
{
|
|
|
|
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 (size <= 4 * 1024 * 1024) return 22;
|
|
|
|
if (size <= 8 * 1024 * 1024) return 23;
|
|
|
|
if (size <= 16 * 1024 * 1024) return 24;
|
|
|
|
if (size <= 32 * 1024 * 1024) return 25;
|
|
|
|
if (size <= 64 * 1024 * 1024) return 26;
|
|
|
|
BUG();
|
|
|
|
|
|
|
|
/* Will never be reached. Needed because the compiler may complain */
|
|
|
|
return -1;
|
|
|
|
}
|
2013-06-14 13:55:13 -06:00
|
|
|
#endif /* !CONFIG_SLOB */
|
2013-01-10 12:14:19 -07:00
|
|
|
|
2016-05-19 18:10:55 -06:00
|
|
|
void *__kmalloc(size_t size, gfp_t flags) __assume_kmalloc_alignment __malloc;
|
|
|
|
void *kmem_cache_alloc(struct kmem_cache *, gfp_t flags) __assume_slab_alignment __malloc;
|
2015-02-12 15:59:32 -07:00
|
|
|
void kmem_cache_free(struct kmem_cache *, void *);
|
2013-09-04 10:35:34 -06:00
|
|
|
|
2015-09-04 16:45:34 -06:00
|
|
|
/*
|
2016-03-15 15:54:03 -06:00
|
|
|
* Bulk allocation and freeing operations. These are accelerated in an
|
2015-09-04 16:45:34 -06:00
|
|
|
* allocator specific way to avoid taking locks repeatedly or building
|
|
|
|
* metadata structures unnecessarily.
|
|
|
|
*
|
|
|
|
* Note that interrupts must be enabled when calling these functions.
|
|
|
|
*/
|
|
|
|
void kmem_cache_free_bulk(struct kmem_cache *, size_t, void **);
|
2015-11-20 16:57:58 -07:00
|
|
|
int kmem_cache_alloc_bulk(struct kmem_cache *, gfp_t, size_t, void **);
|
2015-09-04 16:45:34 -06:00
|
|
|
|
2016-03-15 15:54:00 -06:00
|
|
|
/*
|
|
|
|
* Caller must not use kfree_bulk() on memory not originally allocated
|
|
|
|
* by kmalloc(), because the SLOB allocator cannot handle this.
|
|
|
|
*/
|
|
|
|
static __always_inline void kfree_bulk(size_t size, void **p)
|
|
|
|
{
|
|
|
|
kmem_cache_free_bulk(NULL, size, p);
|
|
|
|
}
|
|
|
|
|
2013-09-04 10:35:34 -06:00
|
|
|
#ifdef CONFIG_NUMA
|
2016-05-19 18:10:55 -06:00
|
|
|
void *__kmalloc_node(size_t size, gfp_t flags, int node) __assume_kmalloc_alignment __malloc;
|
|
|
|
void *kmem_cache_alloc_node(struct kmem_cache *, gfp_t flags, int node) __assume_slab_alignment __malloc;
|
2013-09-04 10:35:34 -06:00
|
|
|
#else
|
|
|
|
static __always_inline void *__kmalloc_node(size_t size, gfp_t flags, int node)
|
|
|
|
{
|
|
|
|
return __kmalloc(size, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static __always_inline void *kmem_cache_alloc_node(struct kmem_cache *s, gfp_t flags, int node)
|
|
|
|
{
|
|
|
|
return kmem_cache_alloc(s, flags);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_TRACING
|
2016-05-19 18:10:55 -06:00
|
|
|
extern void *kmem_cache_alloc_trace(struct kmem_cache *, gfp_t, size_t) __assume_slab_alignment __malloc;
|
2013-09-04 10:35:34 -06:00
|
|
|
|
|
|
|
#ifdef CONFIG_NUMA
|
|
|
|
extern void *kmem_cache_alloc_node_trace(struct kmem_cache *s,
|
|
|
|
gfp_t gfpflags,
|
2016-05-19 18:10:55 -06:00
|
|
|
int node, size_t size) __assume_slab_alignment __malloc;
|
2013-09-04 10:35:34 -06:00
|
|
|
#else
|
|
|
|
static __always_inline void *
|
|
|
|
kmem_cache_alloc_node_trace(struct kmem_cache *s,
|
|
|
|
gfp_t gfpflags,
|
|
|
|
int node, size_t size)
|
|
|
|
{
|
|
|
|
return kmem_cache_alloc_trace(s, gfpflags, size);
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_NUMA */
|
|
|
|
|
|
|
|
#else /* CONFIG_TRACING */
|
|
|
|
static __always_inline void *kmem_cache_alloc_trace(struct kmem_cache *s,
|
|
|
|
gfp_t flags, size_t size)
|
|
|
|
{
|
2015-02-13 15:39:42 -07:00
|
|
|
void *ret = kmem_cache_alloc(s, flags);
|
|
|
|
|
2016-03-25 15:22:02 -06:00
|
|
|
kasan_kmalloc(s, ret, size, flags);
|
2015-02-13 15:39:42 -07:00
|
|
|
return ret;
|
2013-09-04 10:35:34 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static __always_inline void *
|
|
|
|
kmem_cache_alloc_node_trace(struct kmem_cache *s,
|
|
|
|
gfp_t gfpflags,
|
|
|
|
int node, size_t size)
|
|
|
|
{
|
2015-02-13 15:39:42 -07:00
|
|
|
void *ret = kmem_cache_alloc_node(s, gfpflags, node);
|
|
|
|
|
2016-03-25 15:22:02 -06:00
|
|
|
kasan_kmalloc(s, ret, size, gfpflags);
|
2015-02-13 15:39:42 -07:00
|
|
|
return ret;
|
2013-09-04 10:35:34 -06:00
|
|
|
}
|
|
|
|
#endif /* CONFIG_TRACING */
|
|
|
|
|
2016-05-19 18:10:55 -06:00
|
|
|
extern void *kmalloc_order(size_t size, gfp_t flags, unsigned int order) __assume_page_alignment __malloc;
|
2013-09-04 10:35:34 -06:00
|
|
|
|
|
|
|
#ifdef CONFIG_TRACING
|
2016-05-19 18:10:55 -06:00
|
|
|
extern void *kmalloc_order_trace(size_t size, gfp_t flags, unsigned int order) __assume_page_alignment __malloc;
|
2013-09-04 10:35:34 -06:00
|
|
|
#else
|
|
|
|
static __always_inline void *
|
|
|
|
kmalloc_order_trace(size_t size, gfp_t flags, unsigned int order)
|
|
|
|
{
|
|
|
|
return kmalloc_order(size, flags, order);
|
|
|
|
}
|
2013-01-10 12:14:19 -07:00
|
|
|
#endif
|
|
|
|
|
2013-09-04 10:35:34 -06:00
|
|
|
static __always_inline void *kmalloc_large(size_t size, gfp_t flags)
|
|
|
|
{
|
|
|
|
unsigned int order = get_order(size);
|
|
|
|
return kmalloc_order_trace(size, flags, order);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* kmalloc - allocate memory
|
|
|
|
* @size: how many bytes of memory are required.
|
2013-11-22 19:14:38 -07:00
|
|
|
* @flags: the type of memory to allocate.
|
2013-09-04 10:35:34 -06:00
|
|
|
*
|
|
|
|
* kmalloc is the normal method of allocating memory
|
|
|
|
* for objects smaller than page size in the kernel.
|
2013-11-22 19:14:38 -07:00
|
|
|
*
|
|
|
|
* The @flags argument may be one of:
|
|
|
|
*
|
|
|
|
* %GFP_USER - Allocate memory on behalf of user. May sleep.
|
|
|
|
*
|
|
|
|
* %GFP_KERNEL - Allocate normal kernel ram. May sleep.
|
|
|
|
*
|
|
|
|
* %GFP_ATOMIC - Allocation will not sleep. May use emergency pools.
|
|
|
|
* For example, use this inside interrupt handlers.
|
|
|
|
*
|
|
|
|
* %GFP_HIGHUSER - Allocate pages from high memory.
|
|
|
|
*
|
|
|
|
* %GFP_NOIO - Do not do any I/O at all while trying to get memory.
|
|
|
|
*
|
|
|
|
* %GFP_NOFS - Do not make any fs calls while trying to get memory.
|
|
|
|
*
|
|
|
|
* %GFP_NOWAIT - Allocation will not sleep.
|
|
|
|
*
|
2014-03-10 16:49:43 -06:00
|
|
|
* %__GFP_THISNODE - Allocate node-local memory only.
|
2013-11-22 19:14:38 -07:00
|
|
|
*
|
|
|
|
* %GFP_DMA - Allocation suitable for DMA.
|
|
|
|
* Should only be used for kmalloc() caches. Otherwise, use a
|
|
|
|
* slab created with SLAB_DMA.
|
|
|
|
*
|
|
|
|
* Also it is possible to set different flags by OR'ing
|
|
|
|
* in one or more of the following additional @flags:
|
|
|
|
*
|
|
|
|
* %__GFP_COLD - Request cache-cold pages instead of
|
|
|
|
* trying to return cache-warm pages.
|
|
|
|
*
|
|
|
|
* %__GFP_HIGH - This allocation has high priority and may use emergency pools.
|
|
|
|
*
|
|
|
|
* %__GFP_NOFAIL - Indicate that this allocation is in no way allowed to fail
|
|
|
|
* (think twice before using).
|
|
|
|
*
|
|
|
|
* %__GFP_NORETRY - If memory is not immediately available,
|
|
|
|
* then give up at once.
|
|
|
|
*
|
|
|
|
* %__GFP_NOWARN - If allocation fails, don't issue any warnings.
|
|
|
|
*
|
|
|
|
* %__GFP_REPEAT - If allocation fails initially, try once more before failing.
|
|
|
|
*
|
|
|
|
* There are other flags available as well, but these are not intended
|
|
|
|
* for general use, and so are not documented here. For a full list of
|
|
|
|
* potential flags, always refer to linux/gfp.h.
|
2013-09-04 10:35:34 -06:00
|
|
|
*/
|
|
|
|
static __always_inline void *kmalloc(size_t size, gfp_t flags)
|
|
|
|
{
|
|
|
|
if (__builtin_constant_p(size)) {
|
|
|
|
if (size > KMALLOC_MAX_CACHE_SIZE)
|
|
|
|
return kmalloc_large(size, flags);
|
|
|
|
#ifndef CONFIG_SLOB
|
|
|
|
if (!(flags & GFP_DMA)) {
|
|
|
|
int index = kmalloc_index(size);
|
|
|
|
|
|
|
|
if (!index)
|
|
|
|
return ZERO_SIZE_PTR;
|
|
|
|
|
|
|
|
return kmem_cache_alloc_trace(kmalloc_caches[index],
|
|
|
|
flags, size);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
return __kmalloc(size, flags);
|
|
|
|
}
|
|
|
|
|
2013-01-10 12:14:19 -07:00
|
|
|
/*
|
|
|
|
* Determine size used for the nth kmalloc cache.
|
|
|
|
* return size or 0 if a kmalloc cache for that
|
|
|
|
* size does not exist
|
|
|
|
*/
|
|
|
|
static __always_inline int kmalloc_size(int n)
|
|
|
|
{
|
2013-06-14 13:55:13 -06:00
|
|
|
#ifndef CONFIG_SLOB
|
2013-01-10 12:14:19 -07:00
|
|
|
if (n > 2)
|
|
|
|
return 1 << n;
|
|
|
|
|
|
|
|
if (n == 1 && KMALLOC_MIN_SIZE <= 32)
|
|
|
|
return 96;
|
|
|
|
|
|
|
|
if (n == 2 && KMALLOC_MIN_SIZE <= 64)
|
|
|
|
return 192;
|
2013-06-14 13:55:13 -06:00
|
|
|
#endif
|
2013-01-10 12:14:19 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-09-04 10:35:34 -06:00
|
|
|
static __always_inline void *kmalloc_node(size_t size, gfp_t flags, int node)
|
|
|
|
{
|
|
|
|
#ifndef CONFIG_SLOB
|
|
|
|
if (__builtin_constant_p(size) &&
|
2013-09-04 13:58:08 -06:00
|
|
|
size <= KMALLOC_MAX_CACHE_SIZE && !(flags & GFP_DMA)) {
|
2013-09-04 10:35:34 -06:00
|
|
|
int i = kmalloc_index(size);
|
|
|
|
|
|
|
|
if (!i)
|
|
|
|
return ZERO_SIZE_PTR;
|
|
|
|
|
|
|
|
return kmem_cache_alloc_node_trace(kmalloc_caches[i],
|
|
|
|
flags, node, size);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
return __kmalloc_node(size, flags, node);
|
|
|
|
}
|
|
|
|
|
2015-02-12 15:59:20 -07:00
|
|
|
struct memcg_cache_array {
|
|
|
|
struct rcu_head rcu;
|
|
|
|
struct kmem_cache *entries[0];
|
|
|
|
};
|
|
|
|
|
2012-12-18 15:22:27 -07:00
|
|
|
/*
|
|
|
|
* This is the main placeholder for memcg-related information in kmem caches.
|
|
|
|
* Both the root cache and the child caches will have it. For the root cache,
|
|
|
|
* this will hold a dynamically allocated array large enough to hold
|
2014-01-23 16:53:06 -07:00
|
|
|
* information about the currently limited memcgs in the system. To allow the
|
|
|
|
* array to be accessed without taking any locks, on relocation we free the old
|
|
|
|
* version only after a grace period.
|
2012-12-18 15:22:27 -07:00
|
|
|
*
|
|
|
|
* Child caches will hold extra metadata needed for its operation. Fields are:
|
|
|
|
*
|
|
|
|
* @memcg: pointer to the memcg this cache belongs to
|
2012-12-18 15:22:34 -07:00
|
|
|
* @root_cache: pointer to the global, root cache, this cache was derived from
|
2015-02-12 15:59:23 -07:00
|
|
|
*
|
|
|
|
* Both root and child caches of the same kind are linked into a list chained
|
|
|
|
* through @list.
|
2012-12-18 15:22:27 -07:00
|
|
|
*/
|
|
|
|
struct memcg_cache_params {
|
|
|
|
bool is_root_cache;
|
2015-02-12 15:59:23 -07:00
|
|
|
struct list_head list;
|
2012-12-18 15:22:27 -07:00
|
|
|
union {
|
2015-02-12 15:59:20 -07:00
|
|
|
struct memcg_cache_array __rcu *memcg_caches;
|
2012-12-18 15:22:34 -07:00
|
|
|
struct {
|
|
|
|
struct mem_cgroup *memcg;
|
|
|
|
struct kmem_cache *root_cache;
|
|
|
|
};
|
2012-12-18 15:22:27 -07:00
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2012-12-18 15:22:34 -07:00
|
|
|
int memcg_update_all_caches(int num_memcgs);
|
|
|
|
|
2013-06-25 10:16:55 -06:00
|
|
|
/**
|
|
|
|
* kmalloc_array - allocate memory for an array.
|
|
|
|
* @n: number of elements.
|
|
|
|
* @size: element size.
|
|
|
|
* @flags: the type of memory to allocate (see kmalloc).
|
2006-06-23 03:03:48 -06:00
|
|
|
*/
|
2012-03-05 16:14:41 -07:00
|
|
|
static inline void *kmalloc_array(size_t n, size_t size, gfp_t flags)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-05-31 17:26:04 -06:00
|
|
|
if (size != 0 && n > SIZE_MAX / size)
|
slob: initial NUMA support
This adds preliminary NUMA support to SLOB, primarily aimed at systems with
small nodes (tested all the way down to a 128kB SRAM block), whether
asymmetric or otherwise.
We follow the same conventions as SLAB/SLUB, preferring current node
placement for new pages, or with explicit placement, if a node has been
specified. Presently on UP NUMA this has the side-effect of preferring
node#0 allocations (since numa_node_id() == 0, though this could be
reworked if we could hand off a pfn to determine node placement), so
single-CPU NUMA systems will want to place smaller nodes further out in
terms of node id. Once a page has been bound to a node (via explicit node
id typing), we only do block allocations from partial free pages that have
a matching node id in the page flags.
The current implementation does have some scalability problems, in that all
partial free pages are tracked in the global freelist (with contention due
to the single spinlock). However, these are things that are being reworked
for SMP scalability first, while things like per-node freelists can easily
be built on top of this sort of functionality once it's been added.
More background can be found in:
http://marc.info/?l=linux-mm&m=118117916022379&w=2
http://marc.info/?l=linux-mm&m=118170446306199&w=2
http://marc.info/?l=linux-mm&m=118187859420048&w=2
and subsequent threads.
Acked-by: Christoph Lameter <clameter@sgi.com>
Acked-by: Matt Mackall <mpm@selenic.com>
Signed-off-by: Paul Mundt <lethal@linux-sh.org>
Acked-by: Nick Piggin <nickpiggin@yahoo.com.au>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-07-16 00:38:22 -06:00
|
|
|
return NULL;
|
2016-07-26 16:22:08 -06:00
|
|
|
if (__builtin_constant_p(n) && __builtin_constant_p(size))
|
|
|
|
return kmalloc(n * size, flags);
|
2012-03-05 16:14:41 -07:00
|
|
|
return __kmalloc(n * size, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* kcalloc - allocate memory for an array. The memory is set to zero.
|
|
|
|
* @n: number of elements.
|
|
|
|
* @size: element size.
|
|
|
|
* @flags: the type of memory to allocate (see kmalloc).
|
|
|
|
*/
|
|
|
|
static inline void *kcalloc(size_t n, size_t size, gfp_t flags)
|
|
|
|
{
|
|
|
|
return kmalloc_array(n, size, flags | __GFP_ZERO);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-10-04 03:15:25 -06:00
|
|
|
/*
|
|
|
|
* kmalloc_track_caller is a special version of kmalloc that records the
|
|
|
|
* calling function of the routine calling it for slab leak tracking instead
|
|
|
|
* of just the calling function (confusing, eh?).
|
|
|
|
* It's useful when the call to kmalloc comes from a widely-used standard
|
|
|
|
* allocator where we care about the real place the memory allocation
|
|
|
|
* request comes from.
|
|
|
|
*/
|
2008-08-19 11:43:25 -06:00
|
|
|
extern void *__kmalloc_track_caller(size_t, gfp_t, unsigned long);
|
2006-10-04 03:15:25 -06:00
|
|
|
#define kmalloc_track_caller(size, flags) \
|
2008-08-19 11:43:25 -06:00
|
|
|
__kmalloc_track_caller(size, flags, _RET_IP_)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-05-01 09:58:38 -06:00
|
|
|
#ifdef CONFIG_NUMA
|
2008-08-19 11:43:25 -06:00
|
|
|
extern void *__kmalloc_node_track_caller(size_t, gfp_t, int, unsigned long);
|
2006-12-06 21:32:30 -07:00
|
|
|
#define kmalloc_node_track_caller(size, flags, node) \
|
|
|
|
__kmalloc_node_track_caller(size, flags, node, \
|
2008-08-19 11:43:25 -06:00
|
|
|
_RET_IP_)
|
2006-12-13 01:34:23 -07:00
|
|
|
|
2006-12-06 21:32:30 -07:00
|
|
|
#else /* CONFIG_NUMA */
|
|
|
|
|
|
|
|
#define kmalloc_node_track_caller(size, flags, node) \
|
|
|
|
kmalloc_track_caller(size, flags)
|
2005-05-01 09:58:38 -06:00
|
|
|
|
2008-11-25 07:08:19 -07:00
|
|
|
#endif /* CONFIG_NUMA */
|
2006-01-08 02:01:45 -07:00
|
|
|
|
2007-07-17 05:03:29 -06:00
|
|
|
/*
|
|
|
|
* Shortcuts
|
|
|
|
*/
|
|
|
|
static inline void *kmem_cache_zalloc(struct kmem_cache *k, gfp_t flags)
|
|
|
|
{
|
|
|
|
return kmem_cache_alloc(k, flags | __GFP_ZERO);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* kzalloc - allocate memory. The memory is set to zero.
|
|
|
|
* @size: how many bytes of memory are required.
|
|
|
|
* @flags: the type of memory to allocate (see kmalloc).
|
|
|
|
*/
|
|
|
|
static inline void *kzalloc(size_t size, gfp_t flags)
|
|
|
|
{
|
|
|
|
return kmalloc(size, flags | __GFP_ZERO);
|
|
|
|
}
|
|
|
|
|
2008-06-05 23:47:00 -06:00
|
|
|
/**
|
|
|
|
* kzalloc_node - allocate zeroed memory from a particular memory node.
|
|
|
|
* @size: how many bytes of memory are required.
|
|
|
|
* @flags: the type of memory to allocate (see kmalloc).
|
|
|
|
* @node: memory node from which to allocate
|
|
|
|
*/
|
|
|
|
static inline void *kzalloc_node(size_t size, gfp_t flags, int node)
|
|
|
|
{
|
|
|
|
return kmalloc_node(size, flags | __GFP_ZERO, node);
|
|
|
|
}
|
|
|
|
|
2014-10-09 16:26:00 -06:00
|
|
|
unsigned int kmem_cache_size(struct kmem_cache *s);
|
2009-06-12 05:03:06 -06:00
|
|
|
void __init kmem_cache_init_late(void);
|
|
|
|
|
2016-08-23 06:53:19 -06:00
|
|
|
#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
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif /* _LINUX_SLAB_H */
|