Commit 409b0c0169147e8e392886ca441cc95e314b5faf

Authored by Steven Rostedt (Red Hat)
Committed by Greg Kroah-Hartman
1 parent fef76eabdf

tracing: Add condition check to RCU lockdep checks

commit a05d59a5673339ef6936d6940cdf68172ce75b9f upstream.

The trace_tlb_flush() tracepoint can be called when a CPU is going offline.
When a CPU is offline, RCU is no longer watching that CPU and since the
tracepoint is protected by RCU, it must not be called. To prevent the
tlb_flush tracepoint from being called when the CPU is offline, it was
converted to a TRACE_EVENT_CONDITION where the condition checks if the
CPU is online before calling the tracepoint.

Unfortunately, this was not enough to stop lockdep from complaining about
it. Even though the RCU protected code of the tracepoint will never be
called, the condition is hidden within the tracepoint, and even though the
condition prevents RCU code from being called, the lockdep checks are
outside the tracepoint (this is to test tracepoints even when they are not
enabled).

Even though tracepoints should be checked to be RCU safe when they are not
enabled, the condition should still be considered when checking RCU.

Link: http://lkml.kernel.org/r/CA+icZUUGiGDoL5NU8RuxKzFjoLjEKRtUWx=JB8B9a0EQv-eGzQ@mail.gmail.com

Fixes: 3a630178fd5f "tracing: generate RCU warnings even when tracepoints are disabled"
Acked-by: Dave Hansen <dave@sr71.net>
Reported-by: Sedat Dilek <sedat.dilek@gmail.com>
Tested-by: Sedat Dilek <sedat.dilek@gmail.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

Showing 1 changed file with 1 additions and 1 deletions Inline Diff

include/linux/tracepoint.h
1 #ifndef _LINUX_TRACEPOINT_H 1 #ifndef _LINUX_TRACEPOINT_H
2 #define _LINUX_TRACEPOINT_H 2 #define _LINUX_TRACEPOINT_H
3 3
4 /* 4 /*
5 * Kernel Tracepoint API. 5 * Kernel Tracepoint API.
6 * 6 *
7 * See Documentation/trace/tracepoints.txt. 7 * See Documentation/trace/tracepoints.txt.
8 * 8 *
9 * Copyright (C) 2008-2014 Mathieu Desnoyers <mathieu.desnoyers@efficios.com> 9 * Copyright (C) 2008-2014 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
10 * 10 *
11 * Heavily inspired from the Linux Kernel Markers. 11 * Heavily inspired from the Linux Kernel Markers.
12 * 12 *
13 * This file is released under the GPLv2. 13 * This file is released under the GPLv2.
14 * See the file COPYING for more details. 14 * See the file COPYING for more details.
15 */ 15 */
16 16
17 #include <linux/errno.h> 17 #include <linux/errno.h>
18 #include <linux/types.h> 18 #include <linux/types.h>
19 #include <linux/rcupdate.h> 19 #include <linux/rcupdate.h>
20 #include <linux/static_key.h> 20 #include <linux/static_key.h>
21 21
22 struct module; 22 struct module;
23 struct tracepoint; 23 struct tracepoint;
24 struct notifier_block; 24 struct notifier_block;
25 25
26 struct tracepoint_func { 26 struct tracepoint_func {
27 void *func; 27 void *func;
28 void *data; 28 void *data;
29 }; 29 };
30 30
31 struct tracepoint { 31 struct tracepoint {
32 const char *name; /* Tracepoint name */ 32 const char *name; /* Tracepoint name */
33 struct static_key key; 33 struct static_key key;
34 void (*regfunc)(void); 34 void (*regfunc)(void);
35 void (*unregfunc)(void); 35 void (*unregfunc)(void);
36 struct tracepoint_func __rcu *funcs; 36 struct tracepoint_func __rcu *funcs;
37 }; 37 };
38 38
39 extern int 39 extern int
40 tracepoint_probe_register(struct tracepoint *tp, void *probe, void *data); 40 tracepoint_probe_register(struct tracepoint *tp, void *probe, void *data);
41 extern int 41 extern int
42 tracepoint_probe_unregister(struct tracepoint *tp, void *probe, void *data); 42 tracepoint_probe_unregister(struct tracepoint *tp, void *probe, void *data);
43 extern void 43 extern void
44 for_each_kernel_tracepoint(void (*fct)(struct tracepoint *tp, void *priv), 44 for_each_kernel_tracepoint(void (*fct)(struct tracepoint *tp, void *priv),
45 void *priv); 45 void *priv);
46 46
47 #ifdef CONFIG_MODULES 47 #ifdef CONFIG_MODULES
48 struct tp_module { 48 struct tp_module {
49 struct list_head list; 49 struct list_head list;
50 struct module *mod; 50 struct module *mod;
51 }; 51 };
52 52
53 bool trace_module_has_bad_taint(struct module *mod); 53 bool trace_module_has_bad_taint(struct module *mod);
54 extern int register_tracepoint_module_notifier(struct notifier_block *nb); 54 extern int register_tracepoint_module_notifier(struct notifier_block *nb);
55 extern int unregister_tracepoint_module_notifier(struct notifier_block *nb); 55 extern int unregister_tracepoint_module_notifier(struct notifier_block *nb);
56 #else 56 #else
57 static inline bool trace_module_has_bad_taint(struct module *mod) 57 static inline bool trace_module_has_bad_taint(struct module *mod)
58 { 58 {
59 return false; 59 return false;
60 } 60 }
61 static inline 61 static inline
62 int register_tracepoint_module_notifier(struct notifier_block *nb) 62 int register_tracepoint_module_notifier(struct notifier_block *nb)
63 { 63 {
64 return 0; 64 return 0;
65 } 65 }
66 static inline 66 static inline
67 int unregister_tracepoint_module_notifier(struct notifier_block *nb) 67 int unregister_tracepoint_module_notifier(struct notifier_block *nb)
68 { 68 {
69 return 0; 69 return 0;
70 } 70 }
71 #endif /* CONFIG_MODULES */ 71 #endif /* CONFIG_MODULES */
72 72
73 /* 73 /*
74 * tracepoint_synchronize_unregister must be called between the last tracepoint 74 * tracepoint_synchronize_unregister must be called between the last tracepoint
75 * probe unregistration and the end of module exit to make sure there is no 75 * probe unregistration and the end of module exit to make sure there is no
76 * caller executing a probe when it is freed. 76 * caller executing a probe when it is freed.
77 */ 77 */
78 static inline void tracepoint_synchronize_unregister(void) 78 static inline void tracepoint_synchronize_unregister(void)
79 { 79 {
80 synchronize_sched(); 80 synchronize_sched();
81 } 81 }
82 82
83 #ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS 83 #ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS
84 extern void syscall_regfunc(void); 84 extern void syscall_regfunc(void);
85 extern void syscall_unregfunc(void); 85 extern void syscall_unregfunc(void);
86 #endif /* CONFIG_HAVE_SYSCALL_TRACEPOINTS */ 86 #endif /* CONFIG_HAVE_SYSCALL_TRACEPOINTS */
87 87
88 #define PARAMS(args...) args 88 #define PARAMS(args...) args
89 89
90 #endif /* _LINUX_TRACEPOINT_H */ 90 #endif /* _LINUX_TRACEPOINT_H */
91 91
92 /* 92 /*
93 * Note: we keep the TRACE_EVENT and DECLARE_TRACE outside the include 93 * Note: we keep the TRACE_EVENT and DECLARE_TRACE outside the include
94 * file ifdef protection. 94 * file ifdef protection.
95 * This is due to the way trace events work. If a file includes two 95 * This is due to the way trace events work. If a file includes two
96 * trace event headers under one "CREATE_TRACE_POINTS" the first include 96 * trace event headers under one "CREATE_TRACE_POINTS" the first include
97 * will override the TRACE_EVENT and break the second include. 97 * will override the TRACE_EVENT and break the second include.
98 */ 98 */
99 99
100 #ifndef DECLARE_TRACE 100 #ifndef DECLARE_TRACE
101 101
102 #define TP_PROTO(args...) args 102 #define TP_PROTO(args...) args
103 #define TP_ARGS(args...) args 103 #define TP_ARGS(args...) args
104 #define TP_CONDITION(args...) args 104 #define TP_CONDITION(args...) args
105 105
106 #ifdef CONFIG_TRACEPOINTS 106 #ifdef CONFIG_TRACEPOINTS
107 107
108 /* 108 /*
109 * it_func[0] is never NULL because there is at least one element in the array 109 * it_func[0] is never NULL because there is at least one element in the array
110 * when the array itself is non NULL. 110 * when the array itself is non NULL.
111 * 111 *
112 * Note, the proto and args passed in includes "__data" as the first parameter. 112 * Note, the proto and args passed in includes "__data" as the first parameter.
113 * The reason for this is to handle the "void" prototype. If a tracepoint 113 * The reason for this is to handle the "void" prototype. If a tracepoint
114 * has a "void" prototype, then it is invalid to declare a function 114 * has a "void" prototype, then it is invalid to declare a function
115 * as "(void *, void)". The DECLARE_TRACE_NOARGS() will pass in just 115 * as "(void *, void)". The DECLARE_TRACE_NOARGS() will pass in just
116 * "void *data", where as the DECLARE_TRACE() will pass in "void *data, proto". 116 * "void *data", where as the DECLARE_TRACE() will pass in "void *data, proto".
117 */ 117 */
118 #define __DO_TRACE(tp, proto, args, cond, prercu, postrcu) \ 118 #define __DO_TRACE(tp, proto, args, cond, prercu, postrcu) \
119 do { \ 119 do { \
120 struct tracepoint_func *it_func_ptr; \ 120 struct tracepoint_func *it_func_ptr; \
121 void *it_func; \ 121 void *it_func; \
122 void *__data; \ 122 void *__data; \
123 \ 123 \
124 if (!(cond)) \ 124 if (!(cond)) \
125 return; \ 125 return; \
126 prercu; \ 126 prercu; \
127 rcu_read_lock_sched_notrace(); \ 127 rcu_read_lock_sched_notrace(); \
128 it_func_ptr = rcu_dereference_sched((tp)->funcs); \ 128 it_func_ptr = rcu_dereference_sched((tp)->funcs); \
129 if (it_func_ptr) { \ 129 if (it_func_ptr) { \
130 do { \ 130 do { \
131 it_func = (it_func_ptr)->func; \ 131 it_func = (it_func_ptr)->func; \
132 __data = (it_func_ptr)->data; \ 132 __data = (it_func_ptr)->data; \
133 ((void(*)(proto))(it_func))(args); \ 133 ((void(*)(proto))(it_func))(args); \
134 } while ((++it_func_ptr)->func); \ 134 } while ((++it_func_ptr)->func); \
135 } \ 135 } \
136 rcu_read_unlock_sched_notrace(); \ 136 rcu_read_unlock_sched_notrace(); \
137 postrcu; \ 137 postrcu; \
138 } while (0) 138 } while (0)
139 139
140 #ifndef MODULE 140 #ifndef MODULE
141 #define __DECLARE_TRACE_RCU(name, proto, args, cond, data_proto, data_args) \ 141 #define __DECLARE_TRACE_RCU(name, proto, args, cond, data_proto, data_args) \
142 static inline void trace_##name##_rcuidle(proto) \ 142 static inline void trace_##name##_rcuidle(proto) \
143 { \ 143 { \
144 if (static_key_false(&__tracepoint_##name.key)) \ 144 if (static_key_false(&__tracepoint_##name.key)) \
145 __DO_TRACE(&__tracepoint_##name, \ 145 __DO_TRACE(&__tracepoint_##name, \
146 TP_PROTO(data_proto), \ 146 TP_PROTO(data_proto), \
147 TP_ARGS(data_args), \ 147 TP_ARGS(data_args), \
148 TP_CONDITION(cond), \ 148 TP_CONDITION(cond), \
149 rcu_irq_enter(), \ 149 rcu_irq_enter(), \
150 rcu_irq_exit()); \ 150 rcu_irq_exit()); \
151 } 151 }
152 #else 152 #else
153 #define __DECLARE_TRACE_RCU(name, proto, args, cond, data_proto, data_args) 153 #define __DECLARE_TRACE_RCU(name, proto, args, cond, data_proto, data_args)
154 #endif 154 #endif
155 155
156 /* 156 /*
157 * Make sure the alignment of the structure in the __tracepoints section will 157 * Make sure the alignment of the structure in the __tracepoints section will
158 * not add unwanted padding between the beginning of the section and the 158 * not add unwanted padding between the beginning of the section and the
159 * structure. Force alignment to the same alignment as the section start. 159 * structure. Force alignment to the same alignment as the section start.
160 * 160 *
161 * When lockdep is enabled, we make sure to always do the RCU portions of 161 * When lockdep is enabled, we make sure to always do the RCU portions of
162 * the tracepoint code, regardless of whether tracing is on or we match the 162 * the tracepoint code, regardless of whether tracing is on or we match the
163 * condition. This lets us find RCU issues triggered with tracepoints even 163 * condition. This lets us find RCU issues triggered with tracepoints even
164 * when this tracepoint is off. This code has no purpose other than poking 164 * when this tracepoint is off. This code has no purpose other than poking
165 * RCU a bit. 165 * RCU a bit.
166 */ 166 */
167 #define __DECLARE_TRACE(name, proto, args, cond, data_proto, data_args) \ 167 #define __DECLARE_TRACE(name, proto, args, cond, data_proto, data_args) \
168 extern struct tracepoint __tracepoint_##name; \ 168 extern struct tracepoint __tracepoint_##name; \
169 static inline void trace_##name(proto) \ 169 static inline void trace_##name(proto) \
170 { \ 170 { \
171 if (static_key_false(&__tracepoint_##name.key)) \ 171 if (static_key_false(&__tracepoint_##name.key)) \
172 __DO_TRACE(&__tracepoint_##name, \ 172 __DO_TRACE(&__tracepoint_##name, \
173 TP_PROTO(data_proto), \ 173 TP_PROTO(data_proto), \
174 TP_ARGS(data_args), \ 174 TP_ARGS(data_args), \
175 TP_CONDITION(cond),,); \ 175 TP_CONDITION(cond),,); \
176 if (IS_ENABLED(CONFIG_LOCKDEP)) { \ 176 if (IS_ENABLED(CONFIG_LOCKDEP) && (cond)) { \
177 rcu_read_lock_sched_notrace(); \ 177 rcu_read_lock_sched_notrace(); \
178 rcu_dereference_sched(__tracepoint_##name.funcs);\ 178 rcu_dereference_sched(__tracepoint_##name.funcs);\
179 rcu_read_unlock_sched_notrace(); \ 179 rcu_read_unlock_sched_notrace(); \
180 } \ 180 } \
181 } \ 181 } \
182 __DECLARE_TRACE_RCU(name, PARAMS(proto), PARAMS(args), \ 182 __DECLARE_TRACE_RCU(name, PARAMS(proto), PARAMS(args), \
183 PARAMS(cond), PARAMS(data_proto), PARAMS(data_args)) \ 183 PARAMS(cond), PARAMS(data_proto), PARAMS(data_args)) \
184 static inline int \ 184 static inline int \
185 register_trace_##name(void (*probe)(data_proto), void *data) \ 185 register_trace_##name(void (*probe)(data_proto), void *data) \
186 { \ 186 { \
187 return tracepoint_probe_register(&__tracepoint_##name, \ 187 return tracepoint_probe_register(&__tracepoint_##name, \
188 (void *)probe, data); \ 188 (void *)probe, data); \
189 } \ 189 } \
190 static inline int \ 190 static inline int \
191 unregister_trace_##name(void (*probe)(data_proto), void *data) \ 191 unregister_trace_##name(void (*probe)(data_proto), void *data) \
192 { \ 192 { \
193 return tracepoint_probe_unregister(&__tracepoint_##name,\ 193 return tracepoint_probe_unregister(&__tracepoint_##name,\
194 (void *)probe, data); \ 194 (void *)probe, data); \
195 } \ 195 } \
196 static inline void \ 196 static inline void \
197 check_trace_callback_type_##name(void (*cb)(data_proto)) \ 197 check_trace_callback_type_##name(void (*cb)(data_proto)) \
198 { \ 198 { \
199 } \ 199 } \
200 static inline bool \ 200 static inline bool \
201 trace_##name##_enabled(void) \ 201 trace_##name##_enabled(void) \
202 { \ 202 { \
203 return static_key_false(&__tracepoint_##name.key); \ 203 return static_key_false(&__tracepoint_##name.key); \
204 } 204 }
205 205
206 /* 206 /*
207 * We have no guarantee that gcc and the linker won't up-align the tracepoint 207 * We have no guarantee that gcc and the linker won't up-align the tracepoint
208 * structures, so we create an array of pointers that will be used for iteration 208 * structures, so we create an array of pointers that will be used for iteration
209 * on the tracepoints. 209 * on the tracepoints.
210 */ 210 */
211 #define DEFINE_TRACE_FN(name, reg, unreg) \ 211 #define DEFINE_TRACE_FN(name, reg, unreg) \
212 static const char __tpstrtab_##name[] \ 212 static const char __tpstrtab_##name[] \
213 __attribute__((section("__tracepoints_strings"))) = #name; \ 213 __attribute__((section("__tracepoints_strings"))) = #name; \
214 struct tracepoint __tracepoint_##name \ 214 struct tracepoint __tracepoint_##name \
215 __attribute__((section("__tracepoints"))) = \ 215 __attribute__((section("__tracepoints"))) = \
216 { __tpstrtab_##name, STATIC_KEY_INIT_FALSE, reg, unreg, NULL };\ 216 { __tpstrtab_##name, STATIC_KEY_INIT_FALSE, reg, unreg, NULL };\
217 static struct tracepoint * const __tracepoint_ptr_##name __used \ 217 static struct tracepoint * const __tracepoint_ptr_##name __used \
218 __attribute__((section("__tracepoints_ptrs"))) = \ 218 __attribute__((section("__tracepoints_ptrs"))) = \
219 &__tracepoint_##name; 219 &__tracepoint_##name;
220 220
221 #define DEFINE_TRACE(name) \ 221 #define DEFINE_TRACE(name) \
222 DEFINE_TRACE_FN(name, NULL, NULL); 222 DEFINE_TRACE_FN(name, NULL, NULL);
223 223
224 #define EXPORT_TRACEPOINT_SYMBOL_GPL(name) \ 224 #define EXPORT_TRACEPOINT_SYMBOL_GPL(name) \
225 EXPORT_SYMBOL_GPL(__tracepoint_##name) 225 EXPORT_SYMBOL_GPL(__tracepoint_##name)
226 #define EXPORT_TRACEPOINT_SYMBOL(name) \ 226 #define EXPORT_TRACEPOINT_SYMBOL(name) \
227 EXPORT_SYMBOL(__tracepoint_##name) 227 EXPORT_SYMBOL(__tracepoint_##name)
228 228
229 #else /* !CONFIG_TRACEPOINTS */ 229 #else /* !CONFIG_TRACEPOINTS */
230 #define __DECLARE_TRACE(name, proto, args, cond, data_proto, data_args) \ 230 #define __DECLARE_TRACE(name, proto, args, cond, data_proto, data_args) \
231 static inline void trace_##name(proto) \ 231 static inline void trace_##name(proto) \
232 { } \ 232 { } \
233 static inline void trace_##name##_rcuidle(proto) \ 233 static inline void trace_##name##_rcuidle(proto) \
234 { } \ 234 { } \
235 static inline int \ 235 static inline int \
236 register_trace_##name(void (*probe)(data_proto), \ 236 register_trace_##name(void (*probe)(data_proto), \
237 void *data) \ 237 void *data) \
238 { \ 238 { \
239 return -ENOSYS; \ 239 return -ENOSYS; \
240 } \ 240 } \
241 static inline int \ 241 static inline int \
242 unregister_trace_##name(void (*probe)(data_proto), \ 242 unregister_trace_##name(void (*probe)(data_proto), \
243 void *data) \ 243 void *data) \
244 { \ 244 { \
245 return -ENOSYS; \ 245 return -ENOSYS; \
246 } \ 246 } \
247 static inline void check_trace_callback_type_##name(void (*cb)(data_proto)) \ 247 static inline void check_trace_callback_type_##name(void (*cb)(data_proto)) \
248 { \ 248 { \
249 } \ 249 } \
250 static inline bool \ 250 static inline bool \
251 trace_##name##_enabled(void) \ 251 trace_##name##_enabled(void) \
252 { \ 252 { \
253 return false; \ 253 return false; \
254 } 254 }
255 255
256 #define DEFINE_TRACE_FN(name, reg, unreg) 256 #define DEFINE_TRACE_FN(name, reg, unreg)
257 #define DEFINE_TRACE(name) 257 #define DEFINE_TRACE(name)
258 #define EXPORT_TRACEPOINT_SYMBOL_GPL(name) 258 #define EXPORT_TRACEPOINT_SYMBOL_GPL(name)
259 #define EXPORT_TRACEPOINT_SYMBOL(name) 259 #define EXPORT_TRACEPOINT_SYMBOL(name)
260 260
261 #endif /* CONFIG_TRACEPOINTS */ 261 #endif /* CONFIG_TRACEPOINTS */
262 262
263 #ifdef CONFIG_TRACING 263 #ifdef CONFIG_TRACING
264 /** 264 /**
265 * tracepoint_string - register constant persistent string to trace system 265 * tracepoint_string - register constant persistent string to trace system
266 * @str - a constant persistent string that will be referenced in tracepoints 266 * @str - a constant persistent string that will be referenced in tracepoints
267 * 267 *
268 * If constant strings are being used in tracepoints, it is faster and 268 * If constant strings are being used in tracepoints, it is faster and
269 * more efficient to just save the pointer to the string and reference 269 * more efficient to just save the pointer to the string and reference
270 * that with a printf "%s" instead of saving the string in the ring buffer 270 * that with a printf "%s" instead of saving the string in the ring buffer
271 * and wasting space and time. 271 * and wasting space and time.
272 * 272 *
273 * The problem with the above approach is that userspace tools that read 273 * The problem with the above approach is that userspace tools that read
274 * the binary output of the trace buffers do not have access to the string. 274 * the binary output of the trace buffers do not have access to the string.
275 * Instead they just show the address of the string which is not very 275 * Instead they just show the address of the string which is not very
276 * useful to users. 276 * useful to users.
277 * 277 *
278 * With tracepoint_string(), the string will be registered to the tracing 278 * With tracepoint_string(), the string will be registered to the tracing
279 * system and exported to userspace via the debugfs/tracing/printk_formats 279 * system and exported to userspace via the debugfs/tracing/printk_formats
280 * file that maps the string address to the string text. This way userspace 280 * file that maps the string address to the string text. This way userspace
281 * tools that read the binary buffers have a way to map the pointers to 281 * tools that read the binary buffers have a way to map the pointers to
282 * the ASCII strings they represent. 282 * the ASCII strings they represent.
283 * 283 *
284 * The @str used must be a constant string and persistent as it would not 284 * The @str used must be a constant string and persistent as it would not
285 * make sense to show a string that no longer exists. But it is still fine 285 * make sense to show a string that no longer exists. But it is still fine
286 * to be used with modules, because when modules are unloaded, if they 286 * to be used with modules, because when modules are unloaded, if they
287 * had tracepoints, the ring buffers are cleared too. As long as the string 287 * had tracepoints, the ring buffers are cleared too. As long as the string
288 * does not change during the life of the module, it is fine to use 288 * does not change during the life of the module, it is fine to use
289 * tracepoint_string() within a module. 289 * tracepoint_string() within a module.
290 */ 290 */
291 #define tracepoint_string(str) \ 291 #define tracepoint_string(str) \
292 ({ \ 292 ({ \
293 static const char *___tp_str __tracepoint_string = str; \ 293 static const char *___tp_str __tracepoint_string = str; \
294 ___tp_str; \ 294 ___tp_str; \
295 }) 295 })
296 #define __tracepoint_string __attribute__((section("__tracepoint_str"))) 296 #define __tracepoint_string __attribute__((section("__tracepoint_str")))
297 #else 297 #else
298 /* 298 /*
299 * tracepoint_string() is used to save the string address for userspace 299 * tracepoint_string() is used to save the string address for userspace
300 * tracing tools. When tracing isn't configured, there's no need to save 300 * tracing tools. When tracing isn't configured, there's no need to save
301 * anything. 301 * anything.
302 */ 302 */
303 # define tracepoint_string(str) str 303 # define tracepoint_string(str) str
304 # define __tracepoint_string 304 # define __tracepoint_string
305 #endif 305 #endif
306 306
307 /* 307 /*
308 * The need for the DECLARE_TRACE_NOARGS() is to handle the prototype 308 * The need for the DECLARE_TRACE_NOARGS() is to handle the prototype
309 * (void). "void" is a special value in a function prototype and can 309 * (void). "void" is a special value in a function prototype and can
310 * not be combined with other arguments. Since the DECLARE_TRACE() 310 * not be combined with other arguments. Since the DECLARE_TRACE()
311 * macro adds a data element at the beginning of the prototype, 311 * macro adds a data element at the beginning of the prototype,
312 * we need a way to differentiate "(void *data, proto)" from 312 * we need a way to differentiate "(void *data, proto)" from
313 * "(void *data, void)". The second prototype is invalid. 313 * "(void *data, void)". The second prototype is invalid.
314 * 314 *
315 * DECLARE_TRACE_NOARGS() passes "void" as the tracepoint prototype 315 * DECLARE_TRACE_NOARGS() passes "void" as the tracepoint prototype
316 * and "void *__data" as the callback prototype. 316 * and "void *__data" as the callback prototype.
317 * 317 *
318 * DECLARE_TRACE() passes "proto" as the tracepoint protoype and 318 * DECLARE_TRACE() passes "proto" as the tracepoint protoype and
319 * "void *__data, proto" as the callback prototype. 319 * "void *__data, proto" as the callback prototype.
320 */ 320 */
321 #define DECLARE_TRACE_NOARGS(name) \ 321 #define DECLARE_TRACE_NOARGS(name) \
322 __DECLARE_TRACE(name, void, , 1, void *__data, __data) 322 __DECLARE_TRACE(name, void, , 1, void *__data, __data)
323 323
324 #define DECLARE_TRACE(name, proto, args) \ 324 #define DECLARE_TRACE(name, proto, args) \
325 __DECLARE_TRACE(name, PARAMS(proto), PARAMS(args), 1, \ 325 __DECLARE_TRACE(name, PARAMS(proto), PARAMS(args), 1, \
326 PARAMS(void *__data, proto), \ 326 PARAMS(void *__data, proto), \
327 PARAMS(__data, args)) 327 PARAMS(__data, args))
328 328
329 #define DECLARE_TRACE_CONDITION(name, proto, args, cond) \ 329 #define DECLARE_TRACE_CONDITION(name, proto, args, cond) \
330 __DECLARE_TRACE(name, PARAMS(proto), PARAMS(args), PARAMS(cond), \ 330 __DECLARE_TRACE(name, PARAMS(proto), PARAMS(args), PARAMS(cond), \
331 PARAMS(void *__data, proto), \ 331 PARAMS(void *__data, proto), \
332 PARAMS(__data, args)) 332 PARAMS(__data, args))
333 333
334 #define TRACE_EVENT_FLAGS(event, flag) 334 #define TRACE_EVENT_FLAGS(event, flag)
335 335
336 #define TRACE_EVENT_PERF_PERM(event, expr...) 336 #define TRACE_EVENT_PERF_PERM(event, expr...)
337 337
338 #endif /* DECLARE_TRACE */ 338 #endif /* DECLARE_TRACE */
339 339
340 #ifndef TRACE_EVENT 340 #ifndef TRACE_EVENT
341 /* 341 /*
342 * For use with the TRACE_EVENT macro: 342 * For use with the TRACE_EVENT macro:
343 * 343 *
344 * We define a tracepoint, its arguments, its printk format 344 * We define a tracepoint, its arguments, its printk format
345 * and its 'fast binary record' layout. 345 * and its 'fast binary record' layout.
346 * 346 *
347 * Firstly, name your tracepoint via TRACE_EVENT(name : the 347 * Firstly, name your tracepoint via TRACE_EVENT(name : the
348 * 'subsystem_event' notation is fine. 348 * 'subsystem_event' notation is fine.
349 * 349 *
350 * Think about this whole construct as the 350 * Think about this whole construct as the
351 * 'trace_sched_switch() function' from now on. 351 * 'trace_sched_switch() function' from now on.
352 * 352 *
353 * 353 *
354 * TRACE_EVENT(sched_switch, 354 * TRACE_EVENT(sched_switch,
355 * 355 *
356 * * 356 * *
357 * * A function has a regular function arguments 357 * * A function has a regular function arguments
358 * * prototype, declare it via TP_PROTO(): 358 * * prototype, declare it via TP_PROTO():
359 * * 359 * *
360 * 360 *
361 * TP_PROTO(struct rq *rq, struct task_struct *prev, 361 * TP_PROTO(struct rq *rq, struct task_struct *prev,
362 * struct task_struct *next), 362 * struct task_struct *next),
363 * 363 *
364 * * 364 * *
365 * * Define the call signature of the 'function'. 365 * * Define the call signature of the 'function'.
366 * * (Design sidenote: we use this instead of a 366 * * (Design sidenote: we use this instead of a
367 * * TP_PROTO1/TP_PROTO2/TP_PROTO3 ugliness.) 367 * * TP_PROTO1/TP_PROTO2/TP_PROTO3 ugliness.)
368 * * 368 * *
369 * 369 *
370 * TP_ARGS(rq, prev, next), 370 * TP_ARGS(rq, prev, next),
371 * 371 *
372 * * 372 * *
373 * * Fast binary tracing: define the trace record via 373 * * Fast binary tracing: define the trace record via
374 * * TP_STRUCT__entry(). You can think about it like a 374 * * TP_STRUCT__entry(). You can think about it like a
375 * * regular C structure local variable definition. 375 * * regular C structure local variable definition.
376 * * 376 * *
377 * * This is how the trace record is structured and will 377 * * This is how the trace record is structured and will
378 * * be saved into the ring buffer. These are the fields 378 * * be saved into the ring buffer. These are the fields
379 * * that will be exposed to user-space in 379 * * that will be exposed to user-space in
380 * * /sys/kernel/debug/tracing/events/<*>/format. 380 * * /sys/kernel/debug/tracing/events/<*>/format.
381 * * 381 * *
382 * * The declared 'local variable' is called '__entry' 382 * * The declared 'local variable' is called '__entry'
383 * * 383 * *
384 * * __field(pid_t, prev_prid) is equivalent to a standard declariton: 384 * * __field(pid_t, prev_prid) is equivalent to a standard declariton:
385 * * 385 * *
386 * * pid_t prev_pid; 386 * * pid_t prev_pid;
387 * * 387 * *
388 * * __array(char, prev_comm, TASK_COMM_LEN) is equivalent to: 388 * * __array(char, prev_comm, TASK_COMM_LEN) is equivalent to:
389 * * 389 * *
390 * * char prev_comm[TASK_COMM_LEN]; 390 * * char prev_comm[TASK_COMM_LEN];
391 * * 391 * *
392 * 392 *
393 * TP_STRUCT__entry( 393 * TP_STRUCT__entry(
394 * __array( char, prev_comm, TASK_COMM_LEN ) 394 * __array( char, prev_comm, TASK_COMM_LEN )
395 * __field( pid_t, prev_pid ) 395 * __field( pid_t, prev_pid )
396 * __field( int, prev_prio ) 396 * __field( int, prev_prio )
397 * __array( char, next_comm, TASK_COMM_LEN ) 397 * __array( char, next_comm, TASK_COMM_LEN )
398 * __field( pid_t, next_pid ) 398 * __field( pid_t, next_pid )
399 * __field( int, next_prio ) 399 * __field( int, next_prio )
400 * ), 400 * ),
401 * 401 *
402 * * 402 * *
403 * * Assign the entry into the trace record, by embedding 403 * * Assign the entry into the trace record, by embedding
404 * * a full C statement block into TP_fast_assign(). You 404 * * a full C statement block into TP_fast_assign(). You
405 * * can refer to the trace record as '__entry' - 405 * * can refer to the trace record as '__entry' -
406 * * otherwise you can put arbitrary C code in here. 406 * * otherwise you can put arbitrary C code in here.
407 * * 407 * *
408 * * Note: this C code will execute every time a trace event 408 * * Note: this C code will execute every time a trace event
409 * * happens, on an active tracepoint. 409 * * happens, on an active tracepoint.
410 * * 410 * *
411 * 411 *
412 * TP_fast_assign( 412 * TP_fast_assign(
413 * memcpy(__entry->next_comm, next->comm, TASK_COMM_LEN); 413 * memcpy(__entry->next_comm, next->comm, TASK_COMM_LEN);
414 * __entry->prev_pid = prev->pid; 414 * __entry->prev_pid = prev->pid;
415 * __entry->prev_prio = prev->prio; 415 * __entry->prev_prio = prev->prio;
416 * memcpy(__entry->prev_comm, prev->comm, TASK_COMM_LEN); 416 * memcpy(__entry->prev_comm, prev->comm, TASK_COMM_LEN);
417 * __entry->next_pid = next->pid; 417 * __entry->next_pid = next->pid;
418 * __entry->next_prio = next->prio; 418 * __entry->next_prio = next->prio;
419 * ), 419 * ),
420 * 420 *
421 * * 421 * *
422 * * Formatted output of a trace record via TP_printk(). 422 * * Formatted output of a trace record via TP_printk().
423 * * This is how the tracepoint will appear under ftrace 423 * * This is how the tracepoint will appear under ftrace
424 * * plugins that make use of this tracepoint. 424 * * plugins that make use of this tracepoint.
425 * * 425 * *
426 * * (raw-binary tracing wont actually perform this step.) 426 * * (raw-binary tracing wont actually perform this step.)
427 * * 427 * *
428 * 428 *
429 * TP_printk("task %s:%d [%d] ==> %s:%d [%d]", 429 * TP_printk("task %s:%d [%d] ==> %s:%d [%d]",
430 * __entry->prev_comm, __entry->prev_pid, __entry->prev_prio, 430 * __entry->prev_comm, __entry->prev_pid, __entry->prev_prio,
431 * __entry->next_comm, __entry->next_pid, __entry->next_prio), 431 * __entry->next_comm, __entry->next_pid, __entry->next_prio),
432 * 432 *
433 * ); 433 * );
434 * 434 *
435 * This macro construct is thus used for the regular printk format 435 * This macro construct is thus used for the regular printk format
436 * tracing setup, it is used to construct a function pointer based 436 * tracing setup, it is used to construct a function pointer based
437 * tracepoint callback (this is used by programmatic plugins and 437 * tracepoint callback (this is used by programmatic plugins and
438 * can also by used by generic instrumentation like SystemTap), and 438 * can also by used by generic instrumentation like SystemTap), and
439 * it is also used to expose a structured trace record in 439 * it is also used to expose a structured trace record in
440 * /sys/kernel/debug/tracing/events/. 440 * /sys/kernel/debug/tracing/events/.
441 * 441 *
442 * A set of (un)registration functions can be passed to the variant 442 * A set of (un)registration functions can be passed to the variant
443 * TRACE_EVENT_FN to perform any (un)registration work. 443 * TRACE_EVENT_FN to perform any (un)registration work.
444 */ 444 */
445 445
446 #define DECLARE_EVENT_CLASS(name, proto, args, tstruct, assign, print) 446 #define DECLARE_EVENT_CLASS(name, proto, args, tstruct, assign, print)
447 #define DEFINE_EVENT(template, name, proto, args) \ 447 #define DEFINE_EVENT(template, name, proto, args) \
448 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args)) 448 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))
449 #define DEFINE_EVENT_FN(template, name, proto, args, reg, unreg)\ 449 #define DEFINE_EVENT_FN(template, name, proto, args, reg, unreg)\
450 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args)) 450 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))
451 #define DEFINE_EVENT_PRINT(template, name, proto, args, print) \ 451 #define DEFINE_EVENT_PRINT(template, name, proto, args, print) \
452 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args)) 452 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))
453 #define DEFINE_EVENT_CONDITION(template, name, proto, \ 453 #define DEFINE_EVENT_CONDITION(template, name, proto, \
454 args, cond) \ 454 args, cond) \
455 DECLARE_TRACE_CONDITION(name, PARAMS(proto), \ 455 DECLARE_TRACE_CONDITION(name, PARAMS(proto), \
456 PARAMS(args), PARAMS(cond)) 456 PARAMS(args), PARAMS(cond))
457 457
458 #define TRACE_EVENT(name, proto, args, struct, assign, print) \ 458 #define TRACE_EVENT(name, proto, args, struct, assign, print) \
459 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args)) 459 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))
460 #define TRACE_EVENT_FN(name, proto, args, struct, \ 460 #define TRACE_EVENT_FN(name, proto, args, struct, \
461 assign, print, reg, unreg) \ 461 assign, print, reg, unreg) \
462 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args)) 462 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))
463 #define TRACE_EVENT_CONDITION(name, proto, args, cond, \ 463 #define TRACE_EVENT_CONDITION(name, proto, args, cond, \
464 struct, assign, print) \ 464 struct, assign, print) \
465 DECLARE_TRACE_CONDITION(name, PARAMS(proto), \ 465 DECLARE_TRACE_CONDITION(name, PARAMS(proto), \
466 PARAMS(args), PARAMS(cond)) 466 PARAMS(args), PARAMS(cond))
467 467
468 #define TRACE_EVENT_FLAGS(event, flag) 468 #define TRACE_EVENT_FLAGS(event, flag)
469 469
470 #define TRACE_EVENT_PERF_PERM(event, expr...) 470 #define TRACE_EVENT_PERF_PERM(event, expr...)
471 471
472 #endif /* ifdef TRACE_EVENT (see note above) */ 472 #endif /* ifdef TRACE_EVENT (see note above) */
473 473