Linux kernel & device driver programming

Cross-Referenced Linux and Device Driver Code

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ]
Version: [ 2.6.11.8 ] [ 2.6.25 ] [ 2.6.25.8 ] [ 2.6.31.13 ] Architecture: [ i386 ]
  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 void *kmem_cache_alloc(struct kmem_cache *, gfp_t);
 29 void *__kmalloc(size_t size, gfp_t flags);
 30 
 31 static inline void *kmalloc(size_t size, gfp_t flags)
 32 {
 33         if (__builtin_constant_p(size)) {
 34                 int i = 0;
 35 
 36                 if (!size)
 37                         return ZERO_SIZE_PTR;
 38 
 39 #define CACHE(x) \
 40                 if (size <= x) \
 41                         goto found; \
 42                 else \
 43                         i++;
 44 #include <linux/kmalloc_sizes.h>
 45 #undef CACHE
 46                 {
 47                         extern void __you_cannot_kmalloc_that_much(void);
 48                         __you_cannot_kmalloc_that_much();
 49                 }
 50 found:
 51 #ifdef CONFIG_ZONE_DMA
 52                 if (flags & GFP_DMA)
 53                         return kmem_cache_alloc(malloc_sizes[i].cs_dmacachep,
 54                                                 flags);
 55 #endif
 56                 return kmem_cache_alloc(malloc_sizes[i].cs_cachep, flags);
 57         }
 58         return __kmalloc(size, flags);
 59 }
 60 
 61 #ifdef CONFIG_NUMA
 62 extern void *__kmalloc_node(size_t size, gfp_t flags, int node);
 63 extern void *kmem_cache_alloc_node(struct kmem_cache *, gfp_t flags, int node);
 64 
 65 static inline void *kmalloc_node(size_t size, gfp_t flags, int node)
 66 {
 67         if (__builtin_constant_p(size)) {
 68                 int i = 0;
 69 
 70                 if (!size)
 71                         return ZERO_SIZE_PTR;
 72 
 73 #define CACHE(x) \
 74                 if (size <= x) \
 75                         goto found; \
 76                 else \
 77                         i++;
 78 #include <linux/kmalloc_sizes.h>
 79 #undef CACHE
 80                 {
 81                         extern void __you_cannot_kmalloc_that_much(void);
 82                         __you_cannot_kmalloc_that_much();
 83                 }
 84 found:
 85 #ifdef CONFIG_ZONE_DMA
 86                 if (flags & GFP_DMA)
 87                         return kmem_cache_alloc_node(malloc_sizes[i].cs_dmacachep,
 88                                                 flags, node);
 89 #endif
 90                 return kmem_cache_alloc_node(malloc_sizes[i].cs_cachep,
 91                                                 flags, node);
 92         }
 93         return __kmalloc_node(size, flags, node);
 94 }
 95 
 96 #endif  /* CONFIG_NUMA */
 97 
 98 #endif  /* _LINUX_SLAB_DEF_H */
 99 
  This page was automatically generated by the LXR engine.