blob: d530a4460a0b96d4a73ebfb1a65e7fe32547f210 [file] [log] [blame]
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -04001#ifndef _LINUX_TRACEPOINT_H
2#define _LINUX_TRACEPOINT_H
3
4/*
5 * Kernel Tracepoint API.
6 *
Li Hong8cd09a52009-09-22 18:00:44 +08007 * See Documentation/trace/tracepoints.txt.
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -04008 *
9 * (C) Copyright 2008 Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
10 *
11 * Heavily inspired from the Linux Kernel Markers.
12 *
13 * This file is released under the GPLv2.
14 * See the file COPYING for more details.
15 */
16
Wu Zhangjinb70e4f02010-06-21 19:09:09 +080017#include <linux/errno.h>
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -040018#include <linux/types.h>
19#include <linux/rcupdate.h>
Jason Baron8f7b50c2010-09-17 11:09:13 -040020#include <linux/jump_label.h>
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -040021
22struct module;
23struct tracepoint;
24
Steven Rostedt38516ab2010-04-20 17:04:50 -040025struct tracepoint_func {
26 void *func;
27 void *data;
28};
29
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -040030struct tracepoint {
31 const char *name; /* Tracepoint name */
Jason Barond430d3d2011-03-16 17:29:47 -040032 struct jump_label_key key;
Josh Stone97419872009-08-24 14:43:13 -070033 void (*regfunc)(void);
34 void (*unregfunc)(void);
Lai Jiangshanbd1c8b22011-01-04 16:06:09 +080035 struct tracepoint_func __rcu *funcs;
Mathieu Desnoyers65498642011-01-26 17:26:22 -050036};
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -040037
Steven Rostedt2e26ca72010-05-05 10:52:31 -040038/*
39 * Connect a probe to a tracepoint.
40 * Internal API, should not be used directly.
41 */
Steven Rostedt38516ab2010-04-20 17:04:50 -040042extern int tracepoint_probe_register(const char *name, void *probe, void *data);
Steven Rostedt2e26ca72010-05-05 10:52:31 -040043
44/*
45 * Disconnect a probe from a tracepoint.
46 * Internal API, should not be used directly.
47 */
Steven Rostedt38516ab2010-04-20 17:04:50 -040048extern int
49tracepoint_probe_unregister(const char *name, void *probe, void *data);
Steven Rostedt2e26ca72010-05-05 10:52:31 -040050
Steven Rostedt38516ab2010-04-20 17:04:50 -040051extern int tracepoint_probe_register_noupdate(const char *name, void *probe,
52 void *data);
53extern int tracepoint_probe_unregister_noupdate(const char *name, void *probe,
54 void *data);
Steven Rostedt2e26ca72010-05-05 10:52:31 -040055extern void tracepoint_probe_update_all(void);
56
57struct tracepoint_iter {
58 struct module *module;
Mathieu Desnoyers65498642011-01-26 17:26:22 -050059 struct tracepoint * const *tracepoint;
Steven Rostedt2e26ca72010-05-05 10:52:31 -040060};
61
62extern void tracepoint_iter_start(struct tracepoint_iter *iter);
63extern void tracepoint_iter_next(struct tracepoint_iter *iter);
64extern void tracepoint_iter_stop(struct tracepoint_iter *iter);
65extern void tracepoint_iter_reset(struct tracepoint_iter *iter);
Mathieu Desnoyers65498642011-01-26 17:26:22 -050066extern int tracepoint_get_iter_range(struct tracepoint * const **tracepoint,
67 struct tracepoint * const *begin, struct tracepoint * const *end);
Steven Rostedt2e26ca72010-05-05 10:52:31 -040068
69/*
70 * tracepoint_synchronize_unregister must be called between the last tracepoint
71 * probe unregistration and the end of module exit to make sure there is no
72 * caller executing a probe when it is freed.
73 */
74static inline void tracepoint_synchronize_unregister(void)
75{
76 synchronize_sched();
77}
78
79#define PARAMS(args...) args
80
81#ifdef CONFIG_TRACEPOINTS
Mathieu Desnoyers65498642011-01-26 17:26:22 -050082extern
83void tracepoint_update_probe_range(struct tracepoint * const *begin,
84 struct tracepoint * const *end);
Steven Rostedt2e26ca72010-05-05 10:52:31 -040085#else
Mathieu Desnoyers65498642011-01-26 17:26:22 -050086static inline
87void tracepoint_update_probe_range(struct tracepoint * const *begin,
88 struct tracepoint * const *end)
Steven Rostedt2e26ca72010-05-05 10:52:31 -040089{ }
90#endif /* CONFIG_TRACEPOINTS */
91
92#endif /* _LINUX_TRACEPOINT_H */
93
94/*
95 * Note: we keep the TRACE_EVENT and DECLARE_TRACE outside the include
96 * file ifdef protection.
97 * This is due to the way trace events work. If a file includes two
98 * trace event headers under one "CREATE_TRACE_POINTS" the first include
99 * will override the TRACE_EVENT and break the second include.
100 */
101
Steven Rostedtea20d922009-04-10 08:54:16 -0400102#ifndef DECLARE_TRACE
103
Steven Rostedt2939b042009-03-09 15:47:18 -0400104#define TP_PROTO(args...) args
Li Hong8cd09a52009-09-22 18:00:44 +0800105#define TP_ARGS(args...) args
Steven Rostedt287050d2010-12-02 16:46:18 -0500106#define TP_CONDITION(args...) args
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -0400107
108#ifdef CONFIG_TRACEPOINTS
109
110/*
111 * it_func[0] is never NULL because there is at least one element in the array
112 * when the array itself is non NULL.
Steven Rostedt38516ab2010-04-20 17:04:50 -0400113 *
114 * Note, the proto and args passed in includes "__data" as the first parameter.
115 * The reason for this is to handle the "void" prototype. If a tracepoint
116 * has a "void" prototype, then it is invalid to declare a function
117 * as "(void *, void)". The DECLARE_TRACE_NOARGS() will pass in just
118 * "void *data", where as the DECLARE_TRACE() will pass in "void *data, proto".
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -0400119 */
Steven Rostedt287050d2010-12-02 16:46:18 -0500120#define __DO_TRACE(tp, proto, args, cond) \
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -0400121 do { \
Steven Rostedt38516ab2010-04-20 17:04:50 -0400122 struct tracepoint_func *it_func_ptr; \
123 void *it_func; \
124 void *__data; \
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -0400125 \
Steven Rostedt287050d2010-12-02 16:46:18 -0500126 if (!(cond)) \
127 return; \
Mathieu Desnoyersda7b3ea2008-11-14 17:47:43 -0500128 rcu_read_lock_sched_notrace(); \
Steven Rostedt38516ab2010-04-20 17:04:50 -0400129 it_func_ptr = rcu_dereference_sched((tp)->funcs); \
130 if (it_func_ptr) { \
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -0400131 do { \
Steven Rostedt38516ab2010-04-20 17:04:50 -0400132 it_func = (it_func_ptr)->func; \
133 __data = (it_func_ptr)->data; \
134 ((void(*)(proto))(it_func))(args); \
135 } while ((++it_func_ptr)->func); \
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -0400136 } \
Mathieu Desnoyersda7b3ea2008-11-14 17:47:43 -0500137 rcu_read_unlock_sched_notrace(); \
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -0400138 } while (0)
139
140/*
141 * Make sure the alignment of the structure in the __tracepoints section will
142 * not add unwanted padding between the beginning of the section and the
143 * structure. Force alignment to the same alignment as the section start.
144 */
Steven Rostedt287050d2010-12-02 16:46:18 -0500145#define __DECLARE_TRACE(name, proto, args, cond, data_proto, data_args) \
Mathieu Desnoyers7e066fb2008-11-14 17:47:47 -0500146 extern struct tracepoint __tracepoint_##name; \
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -0400147 static inline void trace_##name(proto) \
148 { \
Jason Barond430d3d2011-03-16 17:29:47 -0400149 if (static_branch(&__tracepoint_##name.key)) \
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -0400150 __DO_TRACE(&__tracepoint_##name, \
Steven Rostedt38516ab2010-04-20 17:04:50 -0400151 TP_PROTO(data_proto), \
Steven Rostedt287050d2010-12-02 16:46:18 -0500152 TP_ARGS(data_args), \
153 TP_CONDITION(cond)); \
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -0400154 } \
Steven Rostedt38516ab2010-04-20 17:04:50 -0400155 static inline int \
156 register_trace_##name(void (*probe)(data_proto), void *data) \
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -0400157 { \
Steven Rostedt38516ab2010-04-20 17:04:50 -0400158 return tracepoint_probe_register(#name, (void *)probe, \
159 data); \
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -0400160 } \
Steven Rostedt38516ab2010-04-20 17:04:50 -0400161 static inline int \
162 unregister_trace_##name(void (*probe)(data_proto), void *data) \
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -0400163 { \
Steven Rostedt38516ab2010-04-20 17:04:50 -0400164 return tracepoint_probe_unregister(#name, (void *)probe, \
165 data); \
Mathieu Desnoyers53da59a2010-04-30 12:59:59 -0400166 } \
Steven Rostedt38516ab2010-04-20 17:04:50 -0400167 static inline void \
168 check_trace_callback_type_##name(void (*cb)(data_proto)) \
Mathieu Desnoyers53da59a2010-04-30 12:59:59 -0400169 { \
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -0400170 }
171
Mathieu Desnoyers65498642011-01-26 17:26:22 -0500172/*
173 * We have no guarantee that gcc and the linker won't up-align the tracepoint
174 * structures, so we create an array of pointers that will be used for iteration
175 * on the tracepoints.
176 */
Jason Barond430d3d2011-03-16 17:29:47 -0400177#define DEFINE_TRACE_FN(name, reg, unreg) \
178 static const char __tpstrtab_##name[] \
179 __attribute__((section("__tracepoints_strings"))) = #name; \
180 struct tracepoint __tracepoint_##name \
181 __attribute__((section("__tracepoints"))) = \
182 { __tpstrtab_##name, JUMP_LABEL_INIT, reg, unreg, NULL };\
183 static struct tracepoint * const __tracepoint_ptr_##name __used \
184 __attribute__((section("__tracepoints_ptrs"))) = \
Mathieu Desnoyers65498642011-01-26 17:26:22 -0500185 &__tracepoint_##name;
Josh Stone97419872009-08-24 14:43:13 -0700186
187#define DEFINE_TRACE(name) \
188 DEFINE_TRACE_FN(name, NULL, NULL);
Mathieu Desnoyers7e066fb2008-11-14 17:47:47 -0500189
190#define EXPORT_TRACEPOINT_SYMBOL_GPL(name) \
191 EXPORT_SYMBOL_GPL(__tracepoint_##name)
192#define EXPORT_TRACEPOINT_SYMBOL(name) \
193 EXPORT_SYMBOL(__tracepoint_##name)
194
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -0400195#else /* !CONFIG_TRACEPOINTS */
Steven Rostedt287050d2010-12-02 16:46:18 -0500196#define __DECLARE_TRACE(name, proto, args, cond, data_proto, data_args) \
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -0400197 static inline void trace_##name(proto) \
198 { } \
Steven Rostedt38516ab2010-04-20 17:04:50 -0400199 static inline int \
200 register_trace_##name(void (*probe)(data_proto), \
201 void *data) \
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -0400202 { \
203 return -ENOSYS; \
204 } \
Steven Rostedt38516ab2010-04-20 17:04:50 -0400205 static inline int \
206 unregister_trace_##name(void (*probe)(data_proto), \
207 void *data) \
Mathieu Desnoyersc4209702008-11-14 17:47:44 -0500208 { \
209 return -ENOSYS; \
Mathieu Desnoyers53da59a2010-04-30 12:59:59 -0400210 } \
Steven Rostedt38516ab2010-04-20 17:04:50 -0400211 static inline void check_trace_callback_type_##name(void (*cb)(data_proto)) \
Mathieu Desnoyers53da59a2010-04-30 12:59:59 -0400212 { \
Mathieu Desnoyersc4209702008-11-14 17:47:44 -0500213 }
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -0400214
Josh Stone97419872009-08-24 14:43:13 -0700215#define DEFINE_TRACE_FN(name, reg, unreg)
Mathieu Desnoyers7e066fb2008-11-14 17:47:47 -0500216#define DEFINE_TRACE(name)
217#define EXPORT_TRACEPOINT_SYMBOL_GPL(name)
218#define EXPORT_TRACEPOINT_SYMBOL(name)
219
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -0400220#endif /* CONFIG_TRACEPOINTS */
Steven Rostedt38516ab2010-04-20 17:04:50 -0400221
222/*
223 * The need for the DECLARE_TRACE_NOARGS() is to handle the prototype
224 * (void). "void" is a special value in a function prototype and can
225 * not be combined with other arguments. Since the DECLARE_TRACE()
226 * macro adds a data element at the beginning of the prototype,
227 * we need a way to differentiate "(void *data, proto)" from
228 * "(void *data, void)". The second prototype is invalid.
229 *
230 * DECLARE_TRACE_NOARGS() passes "void" as the tracepoint prototype
231 * and "void *__data" as the callback prototype.
232 *
233 * DECLARE_TRACE() passes "proto" as the tracepoint protoype and
234 * "void *__data, proto" as the callback prototype.
235 */
236#define DECLARE_TRACE_NOARGS(name) \
Steven Rostedt287050d2010-12-02 16:46:18 -0500237 __DECLARE_TRACE(name, void, , 1, void *__data, __data)
Steven Rostedt38516ab2010-04-20 17:04:50 -0400238
239#define DECLARE_TRACE(name, proto, args) \
Steven Rostedt287050d2010-12-02 16:46:18 -0500240 __DECLARE_TRACE(name, PARAMS(proto), PARAMS(args), 1, \
Steven Rostedt38516ab2010-04-20 17:04:50 -0400241 PARAMS(void *__data, proto), \
242 PARAMS(__data, args))
243
Steven Rostedt287050d2010-12-02 16:46:18 -0500244#define DECLARE_TRACE_CONDITION(name, proto, args, cond) \
245 __DECLARE_TRACE(name, PARAMS(proto), PARAMS(args), PARAMS(cond), \
246 PARAMS(void *__data, proto), \
247 PARAMS(__data, args))
248
Frederic Weisbecker1ed0c592010-11-18 01:46:57 +0100249#define TRACE_EVENT_FLAGS(event, flag)
250
Steven Rostedtea20d922009-04-10 08:54:16 -0400251#endif /* DECLARE_TRACE */
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -0400252
Steven Rostedtea20d922009-04-10 08:54:16 -0400253#ifndef TRACE_EVENT
Steven Rostedt823f9122009-03-10 12:58:51 -0400254/*
255 * For use with the TRACE_EVENT macro:
256 *
257 * We define a tracepoint, its arguments, its printk format
258 * and its 'fast binay record' layout.
259 *
260 * Firstly, name your tracepoint via TRACE_EVENT(name : the
261 * 'subsystem_event' notation is fine.
262 *
263 * Think about this whole construct as the
264 * 'trace_sched_switch() function' from now on.
265 *
266 *
267 * TRACE_EVENT(sched_switch,
268 *
269 * *
270 * * A function has a regular function arguments
271 * * prototype, declare it via TP_PROTO():
272 * *
273 *
Steven Rostedtef180122009-03-10 14:10:56 -0400274 * TP_PROTO(struct rq *rq, struct task_struct *prev,
275 * struct task_struct *next),
Steven Rostedt823f9122009-03-10 12:58:51 -0400276 *
277 * *
278 * * Define the call signature of the 'function'.
279 * * (Design sidenote: we use this instead of a
280 * * TP_PROTO1/TP_PROTO2/TP_PROTO3 ugliness.)
281 * *
282 *
Steven Rostedtef180122009-03-10 14:10:56 -0400283 * TP_ARGS(rq, prev, next),
Steven Rostedt823f9122009-03-10 12:58:51 -0400284 *
285 * *
286 * * Fast binary tracing: define the trace record via
287 * * TP_STRUCT__entry(). You can think about it like a
288 * * regular C structure local variable definition.
289 * *
290 * * This is how the trace record is structured and will
291 * * be saved into the ring buffer. These are the fields
292 * * that will be exposed to user-space in
GeunSik Lim156f5a72009-06-02 15:01:37 +0900293 * * /sys/kernel/debug/tracing/events/<*>/format.
Steven Rostedt823f9122009-03-10 12:58:51 -0400294 * *
295 * * The declared 'local variable' is called '__entry'
296 * *
297 * * __field(pid_t, prev_prid) is equivalent to a standard declariton:
298 * *
299 * * pid_t prev_pid;
300 * *
301 * * __array(char, prev_comm, TASK_COMM_LEN) is equivalent to:
302 * *
303 * * char prev_comm[TASK_COMM_LEN];
304 * *
305 *
306 * TP_STRUCT__entry(
307 * __array( char, prev_comm, TASK_COMM_LEN )
308 * __field( pid_t, prev_pid )
309 * __field( int, prev_prio )
310 * __array( char, next_comm, TASK_COMM_LEN )
311 * __field( pid_t, next_pid )
312 * __field( int, next_prio )
313 * ),
314 *
315 * *
316 * * Assign the entry into the trace record, by embedding
317 * * a full C statement block into TP_fast_assign(). You
318 * * can refer to the trace record as '__entry' -
319 * * otherwise you can put arbitrary C code in here.
320 * *
321 * * Note: this C code will execute every time a trace event
322 * * happens, on an active tracepoint.
323 * *
324 *
Steven Rostedtef180122009-03-10 14:10:56 -0400325 * TP_fast_assign(
326 * memcpy(__entry->next_comm, next->comm, TASK_COMM_LEN);
327 * __entry->prev_pid = prev->pid;
328 * __entry->prev_prio = prev->prio;
Steven Rostedt823f9122009-03-10 12:58:51 -0400329 * memcpy(__entry->prev_comm, prev->comm, TASK_COMM_LEN);
330 * __entry->next_pid = next->pid;
Steven Rostedtef180122009-03-10 14:10:56 -0400331 * __entry->next_prio = next->prio;
Mathieu Desnoyersec6e7c32011-01-06 13:45:32 -0500332 * ),
Steven Rostedt823f9122009-03-10 12:58:51 -0400333 *
334 * *
335 * * Formatted output of a trace record via TP_printk().
336 * * This is how the tracepoint will appear under ftrace
337 * * plugins that make use of this tracepoint.
338 * *
339 * * (raw-binary tracing wont actually perform this step.)
340 * *
341 *
342 * TP_printk("task %s:%d [%d] ==> %s:%d [%d]",
343 * __entry->prev_comm, __entry->prev_pid, __entry->prev_prio,
344 * __entry->next_comm, __entry->next_pid, __entry->next_prio),
345 *
346 * );
347 *
348 * This macro construct is thus used for the regular printk format
349 * tracing setup, it is used to construct a function pointer based
350 * tracepoint callback (this is used by programmatic plugins and
351 * can also by used by generic instrumentation like SystemTap), and
352 * it is also used to expose a structured trace record in
GeunSik Lim156f5a72009-06-02 15:01:37 +0900353 * /sys/kernel/debug/tracing/events/.
Josh Stone97419872009-08-24 14:43:13 -0700354 *
355 * A set of (un)registration functions can be passed to the variant
356 * TRACE_EVENT_FN to perform any (un)registration work.
Steven Rostedt823f9122009-03-10 12:58:51 -0400357 */
358
Ingo Molnar091ad362009-11-26 09:04:55 +0100359#define DECLARE_EVENT_CLASS(name, proto, args, tstruct, assign, print)
Steven Rostedtff038f52009-11-18 20:27:27 -0500360#define DEFINE_EVENT(template, name, proto, args) \
361 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))
Steven Rostedte5bc9722009-11-18 20:36:26 -0500362#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \
363 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))
Steven Rostedt287050d2010-12-02 16:46:18 -0500364#define DEFINE_EVENT_CONDITION(template, name, proto, \
365 args, cond) \
366 DECLARE_TRACE_CONDITION(name, PARAMS(proto), \
367 PARAMS(args), PARAMS(cond))
Steven Rostedtff038f52009-11-18 20:27:27 -0500368
Steven Rostedt30a8fec2009-03-10 12:41:38 -0400369#define TRACE_EVENT(name, proto, args, struct, assign, print) \
Steven Rostedtda4d0302009-03-09 17:14:30 -0400370 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))
Josh Stone97419872009-08-24 14:43:13 -0700371#define TRACE_EVENT_FN(name, proto, args, struct, \
372 assign, print, reg, unreg) \
373 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))
Steven Rostedt287050d2010-12-02 16:46:18 -0500374#define TRACE_EVENT_CONDITION(name, proto, args, cond, \
375 struct, assign, print) \
376 DECLARE_TRACE_CONDITION(name, PARAMS(proto), \
377 PARAMS(args), PARAMS(cond))
Steven Rostedt7cb2e3e2009-08-26 00:32:37 -0400378
Frederic Weisbecker1ed0c592010-11-18 01:46:57 +0100379#define TRACE_EVENT_FLAGS(event, flag)
380
Steven Rostedt7cb2e3e2009-08-26 00:32:37 -0400381#endif /* ifdef TRACE_EVENT (see note above) */