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