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         void *p;
  20
  21         run_shrinkers();
  22
  23         p = size
  24             ? aligned_alloc(min(rounddown_pow_of_two(size),
  25                                 PAGE_SIZE), size)
  26             : malloc(0);
  27         if (p && (flags & __GFP_ZERO))
  28                 memset(p, 0, size);
  29
  30         return p;
  31 }
  32
  33 static inline void *krealloc(void *old, size_t size, gfp_t flags)
  34 {
  35         void *new;
  36
  37         run_shrinkers();
  38
  39         new = malloc(size);
  40         if (!new)
  41                 return NULL;
  42
  43         if (flags & __GFP_ZERO)
  44                 memset(new, 0, size);
  45
  46         memcpy(new, old,
  47                min(malloc_usable_size(old),
  48                    malloc_usable_size(new)));
  49         free(old);
  50
  51         return new;
  52 }
  53
  54 #define kzalloc(size, flags)            kmalloc(size, flags|__GFP_ZERO)
  55 #define kmalloc_array(n, size, flags)                                   \
  56         ((size) != 0 && (n) > SIZE_MAX / (size)                         \
  57          ? NULL : kmalloc(n * size, flags))
  58
  59 #define kcalloc(n, size, flags)         kmalloc_array(n, size, flags|__GFP_ZERO)
  60
  61 #define kfree(p)                        free(p)
  62 #define kzfree(p)                       free(p)
  63
  64 #define kvmalloc(size, flags)           kmalloc(size, flags)
  65 #define kvfree(p)                       kfree(p)
  66
  67 static inline struct page *alloc_pages(gfp_t flags, unsigned int order)
  68 {
  69         size_t size = PAGE_SIZE << order;
  70         void *p;
  71
  72         run_shrinkers();
  73
  74         p = aligned_alloc(PAGE_SIZE, size);
  75         if (p && (flags & __GFP_ZERO))
  76                 memset(p, 0, size);
  77
  78         return p;
  79 }
  80
  81 #define alloc_page(gfp)                 alloc_pages(gfp, 0)
  82
  83 #define __get_free_pages(gfp, order)    ((unsigned long) alloc_pages(gfp, order))
  84 #define __get_free_page(gfp)            __get_free_pages(gfp, 0)
  85
  86 #define __free_pages(page, order)                       \
  87 do {                                                    \
  88         (void) order;                                   \
  89         free(page);                                     \
  90 } while (0)
  91
  92 #define free_pages(addr, order)                         \
  93 do {                                                    \
  94         (void) order;                                   \
  95         free((void *) (addr));                          \
  96 } while (0)
  97
  98 #define __free_page(page) __free_pages((page), 0)
  99 #define free_page(addr) free_pages((addr), 0)
 100
 101 #define VM_IOREMAP              0x00000001      /* ioremap() and friends */
 102 #define VM_ALLOC                0x00000002      /* vmalloc() */
 103 #define VM_MAP                  0x00000004      /* vmap()ed pages */
 104 #define VM_USERMAP              0x00000008      /* suitable for remap_vmalloc_range */
 105 #define VM_UNINITIALIZED        0x00000020      /* vm_struct is not fully initialized */
 106 #define VM_NO_GUARD             0x00000040      /* don't add guard page */
 107 #define VM_KASAN                0x00000080      /* has allocated kasan shadow memory */
 108
 109 static inline void vunmap(const void *addr) {}
 110
 111 static inline void *vmap(struct page **pages, unsigned int count,
 112                          unsigned long flags, unsigned prot)
 113 {
 114         return NULL;
 115 }
 116
 117 #define is_vmalloc_addr(page)           0
 118
 119 #define vmalloc_to_page(addr)           ((struct page *) (addr))
 120
 121 static inline void *kmemdup(const void *src, size_t len, gfp_t gfp)
 122 {
 123         void *p;
 124
 125         p = kmalloc(len, gfp);
 126         if (p)
 127                 memcpy(p, src, len);
 128         return p;
 129 }
 130
 131 #endif /* __TOOLS_LINUX_SLAB_H */