Commit 409b0c0169147e8e392886ca441cc95e314b5faf
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 |