1 #ifndef _LINUX_SLUB_DEF_H
2 #define _LINUX_SLUB_DEF_H
5 * SLUB : A Slab allocator without object queues.
7 * (C) 2007 SGI, Christoph Lameter <clameter@sgi.com>
9 #include <linux/types.h>
10 #include <linux/gfp.h>
11 #include <linux/workqueue.h>
12 #include <linux/kobject.h>
14 struct kmem_cache_node
{
15 spinlock_t list_lock
; /* Protect partial list and nr_partial */
16 unsigned long nr_partial
;
17 atomic_long_t nr_slabs
;
18 struct list_head partial
;
19 struct list_head full
;
23 * Slab cache management.
26 /* Used for retriving partial slabs etc */
28 int size
; /* The size of an object including meta data */
29 int objsize
; /* The size of an object without meta data */
30 int offset
; /* Free pointer offset. */
34 * Avoid an extra cache line for UP, SMP and for the node local to
37 struct kmem_cache_node local_node
;
39 /* Allocation and freeing of slabs */
40 int objects
; /* Number of objects in slab */
41 int refcount
; /* Refcount for slab cache destroy */
42 void (*ctor
)(void *, struct kmem_cache
*, unsigned long);
43 void (*dtor
)(void *, struct kmem_cache
*, unsigned long);
44 int inuse
; /* Offset to metadata */
45 int align
; /* Alignment */
46 const char *name
; /* Name (only for display!) */
47 struct list_head list
; /* List of slab caches */
48 struct kobject kobj
; /* For sysfs */
52 struct kmem_cache_node
*node
[MAX_NUMNODES
];
54 struct page
*cpu_slab
[NR_CPUS
];
60 #define KMALLOC_SHIFT_LOW 3
62 #ifdef CONFIG_LARGE_ALLOCS
63 #define KMALLOC_SHIFT_HIGH 25
65 #if !defined(CONFIG_MMU) || NR_CPUS > 512 || MAX_NUMNODES > 256
66 #define KMALLOC_SHIFT_HIGH 20
68 #define KMALLOC_SHIFT_HIGH 18
73 * We keep the general caches in an array of slab caches that are used for
74 * 2^x bytes of allocations.
76 extern struct kmem_cache kmalloc_caches
[KMALLOC_SHIFT_HIGH
+ 1];
79 * Sorry that the following has to be that ugly but some versions of GCC
80 * have trouble with constant propagation and loops.
82 static inline int kmalloc_index(int size
)
85 * We should return 0 if size == 0 but we use the smallest object
86 * here for SLAB legacy reasons.
88 WARN_ON_ONCE(size
== 0);
90 if (size
> 64 && size
<= 96)
92 if (size
> 128 && size
<= 192)
94 if (size
<= 8) return 3;
95 if (size
<= 16) return 4;
96 if (size
<= 32) return 5;
97 if (size
<= 64) return 6;
98 if (size
<= 128) return 7;
99 if (size
<= 256) return 8;
100 if (size
<= 512) return 9;
101 if (size
<= 1024) return 10;
102 if (size
<= 2 * 1024) return 11;
103 if (size
<= 4 * 1024) return 12;
104 if (size
<= 8 * 1024) return 13;
105 if (size
<= 16 * 1024) return 14;
106 if (size
<= 32 * 1024) return 15;
107 if (size
<= 64 * 1024) return 16;
108 if (size
<= 128 * 1024) return 17;
109 if (size
<= 256 * 1024) return 18;
110 #if KMALLOC_SHIFT_HIGH > 18
111 if (size
<= 512 * 1024) return 19;
112 if (size
<= 1024 * 1024) return 20;
114 #if KMALLOC_SHIFT_HIGH > 20
115 if (size
<= 2 * 1024 * 1024) return 21;
116 if (size
<= 4 * 1024 * 1024) return 22;
117 if (size
<= 8 * 1024 * 1024) return 23;
118 if (size
<= 16 * 1024 * 1024) return 24;
119 if (size
<= 32 * 1024 * 1024) return 25;
124 * What we really wanted to do and cannot do because of compiler issues is:
126 * for (i = KMALLOC_SHIFT_LOW; i <= KMALLOC_SHIFT_HIGH; i++)
127 * if (size <= (1 << i))
133 * Find the slab cache for a given combination of allocation flags and size.
135 * This ought to end up with a global pointer to the right cache
138 static inline struct kmem_cache
*kmalloc_slab(size_t size
)
140 int index
= kmalloc_index(size
);
147 * Generate a link failure. Would be great if we could
148 * do something to stop the compile here.
150 extern void __kmalloc_size_too_large(void);
151 __kmalloc_size_too_large();
153 return &kmalloc_caches
[index
];
156 #ifdef CONFIG_ZONE_DMA
157 #define SLUB_DMA __GFP_DMA
159 /* Disable DMA functionality */
163 static inline void *kmalloc(size_t size
, gfp_t flags
)
165 if (__builtin_constant_p(size
) && !(flags
& SLUB_DMA
)) {
166 struct kmem_cache
*s
= kmalloc_slab(size
);
171 return kmem_cache_alloc(s
, flags
);
173 return __kmalloc(size
, flags
);
176 static inline void *kzalloc(size_t size
, gfp_t flags
)
178 if (__builtin_constant_p(size
) && !(flags
& SLUB_DMA
)) {
179 struct kmem_cache
*s
= kmalloc_slab(size
);
184 return kmem_cache_zalloc(s
, flags
);
186 return __kzalloc(size
, flags
);
190 extern void *__kmalloc_node(size_t size
, gfp_t flags
, int node
);
192 static inline void *kmalloc_node(size_t size
, gfp_t flags
, int node
)
194 if (__builtin_constant_p(size
) && !(flags
& SLUB_DMA
)) {
195 struct kmem_cache
*s
= kmalloc_slab(size
);
200 return kmem_cache_alloc_node(s
, flags
, node
);
202 return __kmalloc_node(size
, flags
, node
);
206 #endif /* _LINUX_SLUB_DEF_H */