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