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/overflow.h>
  11 #include <linux/page.h>
  12 #include <linux/shrinker.h>
  13 #include <linux/types.h>
  14
  15 #include <stdlib.h>
  16 #include <sys/mman.h>
  17
  18 #define ARCH_KMALLOC_MINALIGN           16
  19 #define KMALLOC_MAX_SIZE                SIZE_MAX
  20
  21 static inline void *kmalloc(size_t size, gfp_t flags)
  22 {
  23         unsigned i = 0;
  24         void *p;
  25
  26         do {
  27                 run_shrinkers(flags, i != 0);
  28
  29                 if (size) {
  30                         size_t alignment = min(rounddown_pow_of_two(size), (size_t)PAGE_SIZE);
  31                         alignment = max(sizeof(void *), alignment);
  32                         if (posix_memalign(&p, alignment, size))
  33                                 p = NULL;
  34                 } else {
  35                         p = malloc(0);
  36                 }
  37                 if (p && (flags & __GFP_ZERO))
  38                         memset(p, 0, size);
  39         } while (!p && i++ < 10);
  40
  41         return p;
  42 }
  43
  44 static inline void *krealloc(void *old, size_t size, gfp_t flags)
  45 {
  46         void *new;
  47
  48         new = kmalloc(size, flags);
  49         if (!new)
  50                 return NULL;
  51
  52         if (flags & __GFP_ZERO)
  53                 memset(new, 0, size);
  54
  55         if (old) {
  56                 memcpy(new, old,
  57                        min(malloc_usable_size(old),
  58                            malloc_usable_size(new)));
  59                 free(old);
  60         }
  61
  62         return new;
  63 }
  64
  65 static inline void *krealloc_array(void *p, size_t new_n, size_t new_size, gfp_t flags)
  66 {
  67         size_t bytes;
  68
  69         if (unlikely(check_mul_overflow(new_n, new_size, &bytes)))
  70                 return NULL;
  71
  72         return krealloc(p, bytes, flags);
  73 }
  74
  75 #define kzalloc(size, flags)            kmalloc(size, flags|__GFP_ZERO)
  76 #define kmalloc_array(n, size, flags)                                   \
  77         ((size) != 0 && (n) > SIZE_MAX / (size)                         \
  78          ? NULL : kmalloc((n) * (size), flags))
  79
  80 #define kvmalloc_array(n, size, flags)                                  \
  81         ((size) != 0 && (n) > SIZE_MAX / (size)                         \
  82          ? NULL : kmalloc((n) * (size), flags))
  83
  84 #define kcalloc(n, size, flags)         kmalloc_array(n, size, flags|__GFP_ZERO)
  85
  86 #define kfree(p)                        free(p)
  87 #define kzfree(p)                       free(p)
  88
  89 #define kvmalloc(size, flags)           kmalloc(size, flags)
  90 #define kvzalloc(size, flags)           kzalloc(size, flags)
  91 #define kvfree(p)                       kfree(p)
  92
  93 static inline struct page *alloc_pages(gfp_t flags, unsigned int order)
  94 {
  95         size_t size = PAGE_SIZE << order;
  96         unsigned i = 0;
  97         void *p;
  98
  99         do {
 100                 run_shrinkers(flags, i != 0);
 101
 102                 p = aligned_alloc(PAGE_SIZE, size);
 103                 if (p && (flags & __GFP_ZERO))
 104                         memset(p, 0, size);
 105         } while (!p && i++ < 10);
 106
 107         return p;
 108 }
 109
 110 #define alloc_page(gfp)                 alloc_pages(gfp, 0)
 111
 112 #define __get_free_pages(gfp, order)    ((unsigned long) alloc_pages(gfp, order))
 113 #define __get_free_page(gfp)            __get_free_pages(gfp, 0)
 114
 115 #define __free_pages(page, order)                       \
 116 do {                                                    \
 117         (void) order;                                   \
 118         free(page);                                     \
 119 } while (0)
 120
 121 #define free_pages(addr, order)                         \
 122 do {                                                    \
 123         (void) order;                                   \
 124         free((void *) (addr));                          \
 125 } while (0)
 126
 127 #define __free_page(page) __free_pages((page), 0)
 128 #define free_page(addr) free_pages((addr), 0)
 129
 130 #define VM_IOREMAP              0x00000001      /* ioremap() and friends */
 131 #define VM_ALLOC                0x00000002      /* vmalloc() */
 132 #define VM_MAP                  0x00000004      /* vmap()ed pages */
 133 #define VM_USERMAP              0x00000008      /* suitable for remap_vmalloc_range */
 134 #define VM_UNINITIALIZED        0x00000020      /* vm_struct is not fully initialized */
 135 #define VM_NO_GUARD             0x00000040      /* don't add guard page */
 136 #define VM_KASAN                0x00000080      /* has allocated kasan shadow memory */
 137
 138 static inline void vunmap(const void *addr) {}
 139
 140 static inline void *vmap(struct page **pages, unsigned int count,
 141                          unsigned long flags, unsigned prot)
 142 {
 143         return NULL;
 144 }
 145
 146 #define is_vmalloc_addr(page)           0
 147
 148 #define vmalloc_to_page(addr)           ((struct page *) (addr))
 149
 150 static inline void *kmemdup(const void *src, size_t len, gfp_t gfp)
 151 {
 152         void *p;
 153
 154         p = kmalloc(len, gfp);
 155         if (p)
 156                 memcpy(p, src, len);
 157         return p;
 158 }
 159
 160 struct kmem_cache {
 161         size_t              obj_size;
 162 };
 163
 164 static inline void *kmem_cache_alloc(struct kmem_cache *c, gfp_t gfp)
 165 {
 166         return kmalloc(c->obj_size, gfp);
 167 }
 168
 169 static inline void kmem_cache_free(struct kmem_cache *c, void *p)
 170 {
 171         kfree(p);
 172 }
 173
 174 static inline void kmem_cache_destroy(struct kmem_cache *p)
 175 {
 176         kfree(p);
 177 }
 178
 179 static inline struct kmem_cache *kmem_cache_create(size_t obj_size)
 180 {
 181         struct kmem_cache *p = kmalloc(sizeof(*p), GFP_KERNEL);
 182         if (!p)
 183                 return NULL;
 184
 185         p->obj_size = obj_size;
 186         return p;
 187 }
 188
 189 #define KMEM_CACHE(_struct, _flags)     kmem_cache_create(sizeof(struct _struct))
 190
 191 #define PAGE_KERNEL             0
 192 #define PAGE_KERNEL_EXEC        1
 193
 194 #define vfree(p)                free(p)
 195
 196 static inline void *__vmalloc(unsigned long size, gfp_t gfp_mask)
 197 {
 198         unsigned i = 0;
 199         void *p;
 200
 201         size = round_up(size, PAGE_SIZE);
 202
 203         do {
 204                 run_shrinkers(gfp_mask, i != 0);
 205
 206                 p = aligned_alloc(PAGE_SIZE, size);
 207                 if (p && gfp_mask & __GFP_ZERO)
 208                         memset(p, 0, size);
 209         } while (!p && i++ < 10);
 210
 211         return p;
 212 }
 213
 214 static inline void *vmalloc_exec(unsigned long size, gfp_t gfp_mask)
 215 {
 216         void *p;
 217
 218         p = __vmalloc(size, gfp_mask);
 219         if (!p)
 220                 return NULL;
 221
 222         if (mprotect(p, size, PROT_READ|PROT_WRITE|PROT_EXEC)) {
 223                 vfree(p);
 224                 return NULL;
 225         }
 226
 227         return p;
 228 }
 229
 230 static inline void *vmalloc(unsigned long size)
 231 {
 232         return __vmalloc(size, GFP_KERNEL);
 233 }
 234
 235 static inline void *vzalloc(unsigned long size)
 236 {
 237         return __vmalloc(size, GFP_KERNEL|__GFP_ZERO);
 238 }
 239
 240 #endif /* __TOOLS_LINUX_SLAB_H */