[PATCH] optional ZONE_DMA: optional ZONE_DMA in the VM
[linux-2.6.git] / include / linux / slab_def.h
1 #ifndef _LINUX_SLAB_DEF_H
2 #define _LINUX_SLAB_DEF_H
3
4 /*
5  * Definitions unique to the original Linux SLAB allocator.
6  *
7  * What we provide here is a way to optimize the frequent kmalloc
8  * calls in the kernel by selecting the appropriate general cache
9  * if kmalloc was called with a size that can be established at
10  * compile time.
11  */
12
13 #include <linux/init.h>
14 #include <asm/page.h>           /* kmalloc_sizes.h needs PAGE_SIZE */
15 #include <asm/cache.h>          /* kmalloc_sizes.h needs L1_CACHE_BYTES */
16 #include <linux/compiler.h>
17
18 /* Size description struct for general caches. */
19 struct cache_sizes {
20         size_t                  cs_size;
21         struct kmem_cache       *cs_cachep;
22 #ifdef CONFIG_ZONE_DMA
23         struct kmem_cache       *cs_dmacachep;
24 #endif
25 };
26 extern struct cache_sizes malloc_sizes[];
27
28 static inline void *kmalloc(size_t size, gfp_t flags)
29 {
30         if (__builtin_constant_p(size)) {
31                 int i = 0;
32 #define CACHE(x) \
33                 if (size <= x) \
34                         goto found; \
35                 else \
36                         i++;
37 #include "kmalloc_sizes.h"
38 #undef CACHE
39                 {
40                         extern void __you_cannot_kmalloc_that_much(void);
41                         __you_cannot_kmalloc_that_much();
42                 }
43 found:
44 #ifdef CONFIG_ZONE_DMA
45                 if (flags & GFP_DMA)
46                         return kmem_cache_alloc(malloc_sizes[i].cs_dmacachep,
47                                                 flags);
48 #endif
49                 return kmem_cache_alloc(malloc_sizes[i].cs_cachep, flags);
50         }
51         return __kmalloc(size, flags);
52 }
53
54 static inline void *kzalloc(size_t size, gfp_t flags)
55 {
56         if (__builtin_constant_p(size)) {
57                 int i = 0;
58 #define CACHE(x) \
59                 if (size <= x) \
60                         goto found; \
61                 else \
62                         i++;
63 #include "kmalloc_sizes.h"
64 #undef CACHE
65                 {
66                         extern void __you_cannot_kzalloc_that_much(void);
67                         __you_cannot_kzalloc_that_much();
68                 }
69 found:
70 #ifdef CONFIG_ZONE_DMA
71                 if (flags & GFP_DMA)
72                         return kmem_cache_zalloc(malloc_sizes[i].cs_dmacachep,
73                                                 flags);
74 #endif
75                 return kmem_cache_zalloc(malloc_sizes[i].cs_cachep, flags);
76         }
77         return __kzalloc(size, flags);
78 }
79
80 #ifdef CONFIG_NUMA
81 extern void *__kmalloc_node(size_t size, gfp_t flags, int node);
82
83 static inline void *kmalloc_node(size_t size, gfp_t flags, int node)
84 {
85         if (__builtin_constant_p(size)) {
86                 int i = 0;
87 #define CACHE(x) \
88                 if (size <= x) \
89                         goto found; \
90                 else \
91                         i++;
92 #include "kmalloc_sizes.h"
93 #undef CACHE
94                 {
95                         extern void __you_cannot_kmalloc_that_much(void);
96                         __you_cannot_kmalloc_that_much();
97                 }
98 found:
99 #ifdef CONFIG_ZONE_DMA
100                 if (flags & GFP_DMA)
101                         return kmem_cache_alloc_node(malloc_sizes[i].cs_dmacachep,
102                                                 flags, node);
103 #endif
104                 return kmem_cache_alloc_node(malloc_sizes[i].cs_cachep,
105                                                 flags, node);
106         }
107         return __kmalloc_node(size, flags, node);
108 }
109
110 #endif  /* CONFIG_NUMA */
111
112 #endif  /* _LINUX_SLAB_DEF_H */