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