git.sesse.net Git - bcachefs-tools-debian/blob - include/linux/slab.h

   1 #ifndef __TOOLS_LINUX_SLAB_H
   2 #define __TOOLS_LINUX_SLAB_H
   3
   4 #include <malloc.h>
   5 #include <stdlib.h>
   6 #include <string.h>
   7
   8 #include <linux/kernel.h>
   9 #include <linux/log2.h>
  10 #include <linux/page.h>
  11 #include <linux/shrinker.h>
  12 #include <linux/types.h>
  13
  14 #define ARCH_KMALLOC_MINALIGN           16
  15 #define KMALLOC_MAX_SIZE                SIZE_MAX
  16
  17 static inline void *kmalloc(size_t size, gfp_t flags)
  18 {
  19         unsigned i = 0;
  20         void *p;
  21
  22         do {
  23                 run_shrinkers(flags, i != 0);
  24
  25                 if (size) {
  26                         size_t alignment = min(rounddown_pow_of_two(size), (size_t)PAGE_SIZE);
  27                         alignment = max(sizeof(void *), alignment);
  28                         if (posix_memalign(&p, alignment, size))
  29                                 p = NULL;
  30                 } else {
  31                         p = malloc(0);
  32                 }
  33                 if (p && (flags & __GFP_ZERO))
  34                         memset(p, 0, size);
  35         } while (!p && i++ < 10);
  36
  37         return p;
  38 }
  39
  40 static inline void *krealloc(void *old, size_t size, gfp_t flags)
  41 {
  42         void *new;
  43
  44         new = kmalloc(size, flags);
  45         if (!new)
  46                 return NULL;
  47
  48         if (flags & __GFP_ZERO)
  49                 memset(new, 0, size);
  50
  51         if (old) {
  52                 memcpy(new, old,
  53                        min(malloc_usable_size(old),
  54                            malloc_usable_size(new)));
  55                 free(old);
  56         }
  57
  58         return new;
  59 }
  60
  61 #define kzalloc(size, flags)            kmalloc(size, flags|__GFP_ZERO)
  62 #define kmalloc_array(n, size, flags)                                   \
  63         ((size) != 0 && (n) > SIZE_MAX / (size)                         \
  64          ? NULL : kmalloc((n) * (size), flags))
  65
  66 #define kvmalloc_array(n, size, flags)                                  \
  67         ((size) != 0 && (n) > SIZE_MAX / (size)                         \
  68          ? NULL : kmalloc((n) * (size), flags))
  69
  70 #define kcalloc(n, size, flags)         kmalloc_array(n, size, flags|__GFP_ZERO)
  71
  72 #define kfree(p)                        free(p)
  73 #define kzfree(p)                       free(p)
  74
  75 #define kvmalloc(size, flags)           kmalloc(size, flags)
  76 #define kvzalloc(size, flags)           kzalloc(size, flags)
  77 #define kvfree(p)                       kfree(p)
  78
  79 static inline struct page *alloc_pages(gfp_t flags, unsigned int order)
  80 {
  81         size_t size = PAGE_SIZE << order;
  82         unsigned i = 0;
  83         void *p;
  84
  85         do {
  86                 run_shrinkers(flags, i != 0);
  87
  88                 p = aligned_alloc(PAGE_SIZE, size);
  89                 if (p && (flags & __GFP_ZERO))
  90                         memset(p, 0, size);
  91         } while (!p && i++ < 10);
  92
  93         return p;
  94 }
  95
  96 #define alloc_page(gfp)                 alloc_pages(gfp, 0)
  97
  98 #define __get_free_pages(gfp, order)    ((unsigned long) alloc_pages(gfp, order))
  99 #define __get_free_page(gfp)            __get_free_pages(gfp, 0)
 100
 101 #define __free_pages(page, order)                       \
 102 do {                                                    \
 103         (void) order;                                   \
 104         free(page);                                     \
 105 } while (0)
 106
 107 #define free_pages(addr, order)                         \
 108 do {                                                    \
 109         (void) order;                                   \
 110         free((void *) (addr));                          \
 111 } while (0)
 112
 113 #define __free_page(page) __free_pages((page), 0)
 114 #define free_page(addr) free_pages((addr), 0)
 115
 116 #define VM_IOREMAP              0x00000001      /* ioremap() and friends */
 117 #define VM_ALLOC                0x00000002      /* vmalloc() */
 118 #define VM_MAP                  0x00000004      /* vmap()ed pages */
 119 #define VM_USERMAP              0x00000008      /* suitable for remap_vmalloc_range */
 120 #define VM_UNINITIALIZED        0x00000020      /* vm_struct is not fully initialized */
 121 #define VM_NO_GUARD             0x00000040      /* don't add guard page */
 122 #define VM_KASAN                0x00000080      /* has allocated kasan shadow memory */
 123
 124 static inline void vunmap(const void *addr) {}
 125
 126 static inline void *vmap(struct page **pages, unsigned int count,
 127                          unsigned long flags, unsigned prot)
 128 {
 129         return NULL;
 130 }
 131
 132 #define is_vmalloc_addr(page)           0
 133
 134 #define vmalloc_to_page(addr)           ((struct page *) (addr))
 135
 136 static inline void *kmemdup(const void *src, size_t len, gfp_t gfp)
 137 {
 138         void *p;
 139
 140         p = kmalloc(len, gfp);
 141         if (p)
 142                 memcpy(p, src, len);
 143         return p;
 144 }
 145
 146 struct kmem_cache {
 147         size_t              obj_size;
 148 };
 149
 150 static inline void *kmem_cache_alloc(struct kmem_cache *c, gfp_t gfp)
 151 {
 152         return kmalloc(c->obj_size, gfp);
 153 }
 154
 155 static inline void kmem_cache_free(struct kmem_cache *c, void *p)
 156 {
 157         kfree(p);
 158 }
 159
 160 static inline void kmem_cache_destroy(struct kmem_cache *p)
 161 {
 162         kfree(p);
 163 }
 164
 165 static inline struct kmem_cache *kmem_cache_create(size_t obj_size)
 166 {
 167         struct kmem_cache *p = kmalloc(sizeof(*p), GFP_KERNEL);
 168         if (!p)
 169                 return NULL;
 170
 171         p->obj_size = obj_size;
 172         return p;
 173 }
 174
 175 #define KMEM_CACHE(_struct, _flags)     kmem_cache_create(sizeof(struct _struct))
 176
 177 #endif /* __TOOLS_LINUX_SLAB_H */