1 files changed, 58 insertions, 52 deletions
diff --git a/include/linux/kmemcheck.h b/include/linux/kmemcheck.h
index e880d4cf9e22..08d7dc4ddf40 100644
--- a/include/linux/kmemcheck.h
+++ b/include/linux/kmemcheck.h
@@ -36,6 +36,56 @@ int kmemcheck_hide_addr(unsigned long address);
 bool kmemcheck_is_obj_initialized(unsigned long addr, size_t size);
+/*
+ * Bitfield annotations
+ *
+ * How to use: If you have a struct using bitfields, for example
+ *
+ *     struct a {
+ *             int x:8, y:8;
+ *     };
+ *
+ * then this should be rewritten as
+ *
+ *     struct a {
+ *             kmemcheck_bitfield_begin(flags);
+ *             int x:8, y:8;
+ *             kmemcheck_bitfield_end(flags);
+ *     };
+ *
+ * Now the "flags_begin" and "flags_end" members may be used to refer to the
+ * beginning and end, respectively, of the bitfield (and things like
+ * &x.flags_begin is allowed). As soon as the struct is allocated, the bit-
+ * fields should be annotated:
+ *
+ *     struct a *a = kmalloc(sizeof(struct a), GFP_KERNEL);
+ *     kmemcheck_annotate_bitfield(a, flags);
+ */
+#define kmemcheck_bitfield_begin(name)  \
+        int name##_begin[0];
+#define kmemcheck_bitfield_end(name)    \
+        int name##_end[0];
+#define kmemcheck_annotate_bitfield(ptr, name)                          \
+        do {                                                            \
+                int _n;                                                 \
+                                                                        \
+                if (!ptr)                                               \
+                        break;                                          \
+                                                                        \
+                _n = (long) &((ptr)->name##_end)                        \
+                        - (long) &((ptr)->name##_begin);                \
+                MAYBE_BUILD_BUG_ON(_n < 0);                             \
+                                                                        \
+                kmemcheck_mark_initialized(&((ptr)->name##_begin), _n); \
+        } while (0)
+#define kmemcheck_annotate_variable(var)                                \
+        do {                                                            \
+                kmemcheck_mark_initialized(&(var), sizeof(var));        \
+        } while (0)                                                     \
 #else
 #define kmemcheck_enabled 0
@@ -106,60 +156,16 @@ static inline bool kmemcheck_is_obj_initialized(unsigned long addr, size_t size)
        return true;
 }
-#endif /* CONFIG_KMEMCHECK */
+#define kmemcheck_bitfield_begin(name)
+#define kmemcheck_bitfield_end(name)
-/*
+#define kmemcheck_annotate_bitfield(ptr, name)  \
- * Bitfield annotations
+        do {                                    \
- *
+        } while (0)
- * How to use: If you have a struct using bitfields, for example
- *
- *     struct a {
- *             int x:8, y:8;
- *     };
- *
- * then this should be rewritten as
- *
- *     struct a {
- *             kmemcheck_bitfield_begin(flags);
- *             int x:8, y:8;
- *             kmemcheck_bitfield_end(flags);
- *     };
- *
- * Now the "flags_begin" and "flags_end" members may be used to refer to the
- * beginning and end, respectively, of the bitfield (and things like
- * &x.flags_begin is allowed). As soon as the struct is allocated, the bit-
- * fields should be annotated:
- *
- *     struct a *a = kmalloc(sizeof(struct a), GFP_KERNEL);
- *     kmemcheck_annotate_bitfield(a, flags);
- *
- * Note: We provide the same definitions for both kmemcheck and non-
- * kmemcheck kernels. This makes it harder to introduce accidental errors. It
- * is also allowed to pass NULL pointers to kmemcheck_annotate_bitfield().
- */
-#define kmemcheck_bitfield_begin(name)  \
-        int name##_begin[0];
-#define kmemcheck_bitfield_end(name)    \
-        int name##_end[0];
-#define kmemcheck_annotate_bitfield(ptr, name)                          \
+#define kmemcheck_annotate_variable(var)        \
-        do {                                                            \
+        do {                                    \
-                int _n;                                                 \
-                                                                        \
-                if (!ptr)                                               \
-                        break;                                          \
-                                                                        \
-                _n = (long) &((ptr)->name##_end)                        \
-                        - (long) &((ptr)->name##_begin);                \
-                MAYBE_BUILD_BUG_ON(_n < 0);                             \
-                                                                        \
-                kmemcheck_mark_initialized(&((ptr)->name##_begin), _n); \
        } while (0)
-#define kmemcheck_annotate_variable(var)                                \
+#endif /* CONFIG_KMEMCHECK */
-        do {                                                            \
-                kmemcheck_mark_initialized(&(var), sizeof(var));        \
-        } while (0)                                                     \
 #endif /* LINUX_KMEMCHECK_H */

diff --git a/include/linux/kmemcheck.h b/include/linux/kmemcheck.h index e880d4cf9e22..08d7dc4ddf40 100644 --- a/include/linux/kmemcheck.h +++ b/include/linux/kmemcheck.h
@@ -36,6 +36,56 @@ int kmemcheck_hide_addr(unsigned long address);
36		36
37	bool kmemcheck_is_obj_initialized(unsigned long addr, size_t size);	37	bool kmemcheck_is_obj_initialized(unsigned long addr, size_t size);
38		38
		39	/*
		40	* Bitfield annotations
		41	*
		42	* How to use: If you have a struct using bitfields, for example
		43	*
		44	* struct a {
		45	* int x:8, y:8;
		46	* };
		47	*
		48	* then this should be rewritten as
		49	*
		50	* struct a {
		51	* kmemcheck_bitfield_begin(flags);
		52	* int x:8, y:8;
		53	* kmemcheck_bitfield_end(flags);
		54	* };
		55	*
		56	* Now the "flags_begin" and "flags_end" members may be used to refer to the
		57	* beginning and end, respectively, of the bitfield (and things like
		58	* &x.flags_begin is allowed). As soon as the struct is allocated, the bit-
		59	* fields should be annotated:
		60	*
		61	* struct a *a = kmalloc(sizeof(struct a), GFP_KERNEL);
		62	* kmemcheck_annotate_bitfield(a, flags);
		63	*/
		64	#define kmemcheck_bitfield_begin(name) \
		65	int name##_begin[0];
		66
		67	#define kmemcheck_bitfield_end(name) \
		68	int name##_end[0];
		69
		70	#define kmemcheck_annotate_bitfield(ptr, name) \
		71	do { \
		72	int _n; \
		73	\
		74	if (!ptr) \
		75	break; \
		76	\
		77	_n = (long) &((ptr)->name##_end) \
		78	- (long) &((ptr)->name##_begin); \
		79	MAYBE_BUILD_BUG_ON(_n < 0); \
		80	\
		81	kmemcheck_mark_initialized(&((ptr)->name##_begin), _n); \
		82	} while (0)
		83
		84	#define kmemcheck_annotate_variable(var) \
		85	do { \
		86	kmemcheck_mark_initialized(&(var), sizeof(var)); \
		87	} while (0) \
		88
39	#else	89	#else
40	#define kmemcheck_enabled 0	90	#define kmemcheck_enabled 0
41		91
@@ -106,60 +156,16 @@ static inline bool kmemcheck_is_obj_initialized(unsigned long addr, size_t size)
106	return true;	156	return true;
107	}	157	}
108		158
109	#endif /* CONFIG_KMEMCHECK */	159	#define kmemcheck_bitfield_begin(name)
110		160	#define kmemcheck_bitfield_end(name)
111	/*	161	#define kmemcheck_annotate_bitfield(ptr, name) \
112	* Bitfield annotations	162	do { \
113	*	163	} while (0)
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		164
146	#define kmemcheck_annotate_bitfield(ptr, name) \	165	#define kmemcheck_annotate_variable(var) \
147	do { \	166	do { \
148	int _n; \
149	\
150	if (!ptr) \
151	break; \
152	\
153	_n = (long) &((ptr)->name##_end) \
154	- (long) &((ptr)->name##_begin); \
155	MAYBE_BUILD_BUG_ON(_n < 0); \
156	\
157	kmemcheck_mark_initialized(&((ptr)->name##_begin), _n); \
158	} while (0)	167	} while (0)
159		168
160	#define kmemcheck_annotate_variable(var) \	169	#endif /* CONFIG_KMEMCHECK */
161	do { \
162	kmemcheck_mark_initialized(&(var), sizeof(var)); \
163	} while (0) \
164		170
165	#endif /* LINUX_KMEMCHECK_H */	171	#endif /* LINUX_KMEMCHECK_H */