1 /* 2 * Written by Mark Hemment, 1996 ([email protected]). 3 * 4 * (C) SGI 2006, Christoph Lameter 5 * Cleaned up and restructured to ease the addition of alternative 6 * implementations of SLAB allocators. 7 */ 8 9 #ifndef _LINUX_SLAB_H 10 #define _LINUX_SLAB_H 11 12 #include <linux/gfp.h> 13 #include <linux/types.h> 14 15 /* 16 * Flags to pass to kmem_cache_create(). 17 * The ones marked DEBUG are only valid if CONFIG_SLAB_DEBUG is set. 18 */ 19 #define SLAB_DEBUG_FREE 0x00000100UL /* DEBUG: Perform (expensive) checks on free */ 20 #define SLAB_RED_ZONE 0x00000400UL /* DEBUG: Red zone objs in a cache */ 21 #define SLAB_POISON 0x00000800UL /* DEBUG: Poison objects */ 22 #define SLAB_HWCACHE_ALIGN 0x00002000UL /* Align objs on cache lines */ 23 #define SLAB_CACHE_DMA 0x00004000UL /* Use GFP_DMA memory */ 24 #define SLAB_STORE_USER 0x00010000UL /* DEBUG: Store the last owner for bug hunting */ 25 #define SLAB_PANIC 0x00040000UL /* Panic if kmem_cache_create() fails */ 26 #define SLAB_DESTROY_BY_RCU 0x00080000UL /* Defer freeing slabs to RCU */ 27 #define SLAB_MEM_SPREAD 0x00100000UL /* Spread some memory over cpuset */ 28 #define SLAB_TRACE 0x00200000UL /* Trace allocations and frees */ 29 30 /* Flag to prevent checks on free */ 31 #ifdef CONFIG_DEBUG_OBJECTS 32 # define SLAB_DEBUG_OBJECTS 0x00400000UL 33 #else 34 # define SLAB_DEBUG_OBJECTS 0x00000000UL 35 #endif 36 37 /* The following flags affect the page allocator grouping pages by mobility */ 38 #define SLAB_RECLAIM_ACCOUNT 0x00020000UL /* Objects are reclaimable */ 39 #define SLAB_TEMPORARY SLAB_RECLAIM_ACCOUNT /* Objects are short-lived */ 40 /* 41 * ZERO_SIZE_PTR will be returned for zero sized kmalloc requests. 42 * 43 * Dereferencing ZERO_SIZE_PTR will lead to a distinct access fault. 44 * 45 * ZERO_SIZE_PTR can be passed to kfree though in the same way that NULL can. 46 * Both make kfree a no-op. 47 */ 48 #define ZERO_SIZE_PTR ((void *)16) 49 50 #define ZERO_OR_NULL_PTR(x) ((unsigned long)(x) <= \ 51 (unsigned long)ZERO_SIZE_PTR) 52 53 /* 54 * struct kmem_cache related prototypes 55 */ 56 void __init kmem_cache_init(void); 57 int slab_is_available(void); 58 59 struct kmem_cache *kmem_cache_create(const char *, size_t, size_t, 60 unsigned long, 61 void (*)(struct kmem_cache *, void *)); 62 void kmem_cache_destroy(struct kmem_cache *); 63 int kmem_cache_shrink(struct kmem_cache *); 64 void kmem_cache_free(struct kmem_cache *, void *); 65 unsigned int kmem_cache_size(struct kmem_cache *); 66 const char *kmem_cache_name(struct kmem_cache *); 67 int kmem_ptr_validate(struct kmem_cache *cachep, const void *ptr); 68 69 /* 70 * Please use this macro to create slab caches. Simply specify the 71 * name of the structure and maybe some flags that are listed above. 72 * 73 * The alignment of the struct determines object alignment. If you 74 * f.e. add ____cacheline_aligned_in_smp to the struct declaration 75 * then the objects will be properly aligned in SMP configurations. 76 */ 77 #define KMEM_CACHE(__struct, __flags) kmem_cache_create(#__struct,\ 78 sizeof(struct __struct), __alignof__(struct __struct),\ 79 (__flags), NULL) 80 81 /* 82 * The largest kmalloc size supported by the slab allocators is 83 * 32 megabyte (2^25) or the maximum allocatable page order if that is 84 * less than 32 MB. 85 * 86 * WARNING: Its not easy to increase this value since the allocators have 87 * to do various tricks to work around compiler limitations in order to 88 * ensure proper constant folding. 89 */ 90 #define KMALLOC_SHIFT_HIGH ((MAX_ORDER + PAGE_SHIFT - 1) <= 25 ? \ 91 (MAX_ORDER + PAGE_SHIFT - 1) : 25) 92 93 #define KMALLOC_MAX_SIZE (1UL << KMALLOC_SHIFT_HIGH) 94 #define KMALLOC_MAX_ORDER (KMALLOC_SHIFT_HIGH - PAGE_SHIFT) 95 96 /* 97 * Common kmalloc functions provided by all allocators 98 */ 99 void * __must_check krealloc(const void *, size_t, gfp_t); 100 void kfree(const void *); 101 size_t ksize(const void *); 102 103 /* 104 * Allocator specific definitions. These are mainly used to establish optimized 105 * ways to convert kmalloc() calls to kmem_cache_alloc() invocations by 106 * selecting the appropriate general cache at compile time. 107 * 108 * Allocators must define at least: 109 * 110 * kmem_cache_alloc() 111 * __kmalloc() 112 * kmalloc() 113 * 114 * Those wishing to support NUMA must also define: 115 * 116 * kmem_cache_alloc_node() 117 * kmalloc_node() 118 * 119 * See each allocator definition file for additional comments and 120 * implementation notes. 121 */ 122 #ifdef CONFIG_SLUB 123 #include <linux/slub_def.h> 124 #elif defined(CONFIG_SLOB) 125 #include <linux/slob_def.h> 126 #else 127 #include <linux/slab_def.h> 128 #endif 129 130 /** 131 * kcalloc - allocate memory for an array. The memory is set to zero. 132 * @n: number of elements. 133 * @size: element size. 134 * @flags: the type of memory to allocate. 135 * 136 * The @flags argument may be one of: 137 * 138 * %GFP_USER - Allocate memory on behalf of user. May sleep. 139 * 140 * %GFP_KERNEL - Allocate normal kernel ram. May sleep. 141 * 142 * %GFP_ATOMIC - Allocation will not sleep. May use emergency pools. 143 * For example, use this inside interrupt handlers. 144 * 145 * %GFP_HIGHUSER - Allocate pages from high memory. 146 * 147 * %GFP_NOIO - Do not do any I/O at all while trying to get memory. 148 * 149 * %GFP_NOFS - Do not make any fs calls while trying to get memory. 150 * 151 * %GFP_NOWAIT - Allocation will not sleep. 152 * 153 * %GFP_THISNODE - Allocate node-local memory only. 154 * 155 * %GFP_DMA - Allocation suitable for DMA. 156 * Should only be used for kmalloc() caches. Otherwise, use a 157 * slab created with SLAB_DMA. 158 * 159 * Also it is possible to set different flags by OR'ing 160 * in one or more of the following additional @flags: 161 * 162 * %__GFP_COLD - Request cache-cold pages instead of 163 * trying to return cache-warm pages. 164 * 165 * %__GFP_HIGH - This allocation has high priority and may use emergency pools. 166 * 167 * %__GFP_NOFAIL - Indicate that this allocation is in no way allowed to fail 168 * (think twice before using). 169 * 170 * %__GFP_NORETRY - If memory is not immediately available, 171 * then give up at once. 172 * 173 * %__GFP_NOWARN - If allocation fails, don't issue any warnings. 174 * 175 * %__GFP_REPEAT - If allocation fails initially, try once more before failing. 176 * 177 * There are other flags available as well, but these are not intended 178 * for general use, and so are not documented here. For a full list of 179 * potential flags, always refer to linux/gfp.h. 180 */ 181 static inline void *kcalloc(size_t n, size_t size, gfp_t flags) 182 { 183 if (size != 0 && n > ULONG_MAX / size) 184 return NULL; 185 return __kmalloc(n * size, flags | __GFP_ZERO); 186 } 187 188 #if !defined(CONFIG_NUMA) && !defined(CONFIG_SLOB) 189 /** 190 * kmalloc_node - allocate memory from a specific node 191 * @size: how many bytes of memory are required. 192 * @flags: the type of memory to allocate (see kcalloc). 193 * @node: node to allocate from. 194 * 195 * kmalloc() for non-local nodes, used to allocate from a specific node 196 * if available. Equivalent to kmalloc() in the non-NUMA single-node 197 * case. 198 */ 199 static inline void *kmalloc_node(size_t size, gfp_t flags, int node) 200 { 201 return kmalloc(size, flags); 202 } 203 204 static inline void *__kmalloc_node(size_t size, gfp_t flags, int node) 205 { 206 return __kmalloc(size, flags); 207 } 208 209 void *kmem_cache_alloc(struct kmem_cache *, gfp_t); 210 211 static inline void *kmem_cache_alloc_node(struct kmem_cache *cachep, 212 gfp_t flags, int node) 213 { 214 return kmem_cache_alloc(cachep, flags); 215 } 216 #endif /* !CONFIG_NUMA && !CONFIG_SLOB */ 217 218 /* 219 * kmalloc_track_caller is a special version of kmalloc that records the 220 * calling function of the routine calling it for slab leak tracking instead 221 * of just the calling function (confusing, eh?). 222 * It's useful when the call to kmalloc comes from a widely-used standard 223 * allocator where we care about the real place the memory allocation 224 * request comes from. 225 */ 226 #if defined(CONFIG_DEBUG_SLAB) || defined(CONFIG_SLUB) 227 extern void *__kmalloc_track_caller(size_t, gfp_t, void*); 228 #define kmalloc_track_caller(size, flags) \ 229 __kmalloc_track_caller(size, flags, __builtin_return_address(0)) 230 #else 231 #define kmalloc_track_caller(size, flags) \ 232 __kmalloc(size, flags) 233 #endif /* DEBUG_SLAB */ 234 235 #ifdef CONFIG_NUMA 236 /* 237 * kmalloc_node_track_caller is a special version of kmalloc_node that 238 * records the calling function of the routine calling it for slab leak 239 * tracking instead of just the calling function (confusing, eh?). 240 * It's useful when the call to kmalloc_node comes from a widely-used 241 * standard allocator where we care about the real place the memory 242 * allocation request comes from. 243 */ 244 #if defined(CONFIG_DEBUG_SLAB) || defined(CONFIG_SLUB) 245 extern void *__kmalloc_node_track_caller(size_t, gfp_t, int, void *); 246 #define kmalloc_node_track_caller(size, flags, node) \ 247 __kmalloc_node_track_caller(size, flags, node, \ 248 __builtin_return_address(0)) 249 #else 250 #define kmalloc_node_track_caller(size, flags, node) \ 251 __kmalloc_node(size, flags, node) 252 #endif 253 254 #else /* CONFIG_NUMA */ 255 256 #define kmalloc_node_track_caller(size, flags, node) \ 257 kmalloc_track_caller(size, flags) 258 259 #endif /* DEBUG_SLAB */ 260 261 /* 262 * Shortcuts 263 */ 264 static inline void *kmem_cache_zalloc(struct kmem_cache *k, gfp_t flags) 265 { 266 return kmem_cache_alloc(k, flags | __GFP_ZERO); 267 } 268 269 /** 270 * kzalloc - allocate memory. The memory is set to zero. 271 * @size: how many bytes of memory are required. 272 * @flags: the type of memory to allocate (see kmalloc). 273 */ 274 static inline void *kzalloc(size_t size, gfp_t flags) 275 { 276 return kmalloc(size, flags | __GFP_ZERO); 277 } 278 279 /** 280 * kzalloc_node - allocate zeroed memory from a particular memory node. 281 * @size: how many bytes of memory are required. 282 * @flags: the type of memory to allocate (see kmalloc). 283 * @node: memory node from which to allocate 284 */ 285 static inline void *kzalloc_node(size_t size, gfp_t flags, int node) 286 { 287 return kmalloc_node(size, flags | __GFP_ZERO, node); 288 } 289 290 #ifdef CONFIG_SLABINFO 291 extern const struct seq_operations slabinfo_op; 292 ssize_t slabinfo_write(struct file *, const char __user *, size_t, loff_t *); 293 #endif 294 295 #endif /* _LINUX_SLAB_H */ 296