include/linux/kmemcheck.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef LINUX_KMEMCHECK_H
   3 #define LINUX_KMEMCHECK_H
   4
   5 #include <linux/mm_types.h>
   6 #include <linux/types.h>
   7
   8 #ifdef CONFIG_KMEMCHECK
   9 extern int kmemcheck_enabled;
  10
  11 /* The slab-related functions. */
  12 void kmemcheck_alloc_shadow(struct page *page, int order, gfp_t flags, int node);
  13 void kmemcheck_free_shadow(struct page *page, int order);
  14 void kmemcheck_slab_alloc(struct kmem_cache *s, gfp_t gfpflags, void *object,
  15                           size_t size);
  16 void kmemcheck_slab_free(struct kmem_cache *s, void *object, size_t size);
  17
  18 void kmemcheck_pagealloc_alloc(struct page *p, unsigned int order,
  19                                gfp_t gfpflags);
  20
  21 void kmemcheck_show_pages(struct page *p, unsigned int n);
  22 void kmemcheck_hide_pages(struct page *p, unsigned int n);
  23
  24 bool kmemcheck_page_is_tracked(struct page *p);
  25
  26 void kmemcheck_mark_unallocated(void *address, unsigned int n);
  27 void kmemcheck_mark_uninitialized(void *address, unsigned int n);
  28 void kmemcheck_mark_initialized(void *address, unsigned int n);
  29 void kmemcheck_mark_freed(void *address, unsigned int n);
  30
  31 void kmemcheck_mark_unallocated_pages(struct page *p, unsigned int n);
  32 void kmemcheck_mark_uninitialized_pages(struct page *p, unsigned int n);
  33 void kmemcheck_mark_initialized_pages(struct page *p, unsigned int n);
  34
  35 int kmemcheck_show_addr(unsigned long address);
  36 int kmemcheck_hide_addr(unsigned long address);
  37
  38 bool kmemcheck_is_obj_initialized(unsigned long addr, size_t size);
  39
  40 /*
  41  * Bitfield annotations
  42  *
  43  * How to use: If you have a struct using bitfields, for example
  44  *
  45  *     struct a {
  46  *             int x:8, y:8;
  47  *     };
  48  *
  49  * then this should be rewritten as
  50  *
  51  *     struct a {
  52  *             kmemcheck_bitfield_begin(flags);
  53  *             int x:8, y:8;
  54  *             kmemcheck_bitfield_end(flags);
  55  *     };
  56  *
  57  * Now the "flags_begin" and "flags_end" members may be used to refer to the
  58  * beginning and end, respectively, of the bitfield (and things like
  59  * &x.flags_begin is allowed). As soon as the struct is allocated, the bit-
  60  * fields should be annotated:
  61  *
  62  *     struct a *a = kmalloc(sizeof(struct a), GFP_KERNEL);
  63  *     kmemcheck_annotate_bitfield(a, flags);
  64  */
  65 #define kmemcheck_bitfield_begin(name)  \
  66         int name##_begin[0];
  67
  68 #define kmemcheck_bitfield_end(name)    \
  69         int name##_end[0];
  70
  71 #define kmemcheck_annotate_bitfield(ptr, name)                          \
  72         do {                                                            \
  73                 int _n;                                                 \
  74                                                                         \
  75                 if (!ptr)                                               \
  76                         break;                                          \
  77                                                                         \
  78                 _n = (long) &((ptr)->name##_end)                        \
  79                         - (long) &((ptr)->name##_begin);                \
  80                 BUILD_BUG_ON(_n < 0);                                   \
  81                                                                         \
  82                 kmemcheck_mark_initialized(&((ptr)->name##_begin), _n); \
  83         } while (0)
  84
  85 #define kmemcheck_annotate_variable(var)                                \
  86         do {                                                            \
  87                 kmemcheck_mark_initialized(&(var), sizeof(var));        \
  88         } while (0)                                                     \
  89
  90 #else
  91 #define kmemcheck_enabled 0
  92
  93 static inline void
  94 kmemcheck_alloc_shadow(struct page *page, int order, gfp_t flags, int node)
  95 {
  96 }
  97
  98 static inline void
  99 kmemcheck_free_shadow(struct page *page, int order)
 100 {
 101 }
 102
 103 static inline void
 104 kmemcheck_slab_alloc(struct kmem_cache *s, gfp_t gfpflags, void *object,
 105                      size_t size)
 106 {
 107 }
 108
 109 static inline void kmemcheck_slab_free(struct kmem_cache *s, void *object,
 110                                        size_t size)
 111 {
 112 }
 113
 114 static inline void kmemcheck_pagealloc_alloc(struct page *p,
 115         unsigned int order, gfp_t gfpflags)
 116 {
 117 }
 118
 119 static inline bool kmemcheck_page_is_tracked(struct page *p)
 120 {
 121         return false;
 122 }
 123
 124 static inline void kmemcheck_mark_unallocated(void *address, unsigned int n)
 125 {
 126 }
 127
 128 static inline void kmemcheck_mark_uninitialized(void *address, unsigned int n)
 129 {
 130 }
 131
 132 static inline void kmemcheck_mark_initialized(void *address, unsigned int n)
 133 {
 134 }
 135
 136 static inline void kmemcheck_mark_freed(void *address, unsigned int n)
 137 {
 138 }
 139
 140 static inline void kmemcheck_mark_unallocated_pages(struct page *p,
 141                                                     unsigned int n)
 142 {
 143 }
 144
 145 static inline void kmemcheck_mark_uninitialized_pages(struct page *p,
 146                                                       unsigned int n)
 147 {
 148 }
 149
 150 static inline void kmemcheck_mark_initialized_pages(struct page *p,
 151                                                     unsigned int n)
 152 {
 153 }
 154
 155 static inline bool kmemcheck_is_obj_initialized(unsigned long addr, size_t size)
 156 {
 157         return true;
 158 }
 159
 160 #define kmemcheck_bitfield_begin(name)
 161 #define kmemcheck_bitfield_end(name)
 162 #define kmemcheck_annotate_bitfield(ptr, name)  \
 163         do {                                    \
 164         } while (0)
 165
 166 #define kmemcheck_annotate_variable(var)        \
 167         do {                                    \
 168         } while (0)
 169
 170 #endif /* CONFIG_KMEMCHECK */
 171
 172 #endif /* LINUX_KMEMCHECK_H */