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