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