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