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 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 "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 "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 extern const struct seq_operations slabinfo_op;
  99 ssize_t slabinfo_write(struct file *, const char __user *, size_t, loff_t *);
 100
 101 #endif  /* _LINUX_SLAB_DEF_H */