~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/linux/tracepoint.h

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.11 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.84 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.154 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.201 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.201 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.77 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 #ifndef _LINUX_TRACEPOINT_H
  2 #define _LINUX_TRACEPOINT_H
  3 
  4 /*
  5  * Kernel Tracepoint API.
  6  *
  7  * See Documentation/trace/tracepoints.txt.
  8  *
  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 
 17 #include <linux/errno.h>
 18 #include <linux/types.h>
 19 #include <linux/rcupdate.h>
 20 #include <linux/jump_label.h>
 21 
 22 struct module;
 23 struct tracepoint;
 24 
 25 struct tracepoint_func {
 26         void *func;
 27         void *data;
 28 };
 29 
 30 struct tracepoint {
 31         const char *name;               /* Tracepoint name */
 32         struct jump_label_key key;
 33         void (*regfunc)(void);
 34         void (*unregfunc)(void);
 35         struct tracepoint_func __rcu *funcs;
 36 };
 37 
 38 /*
 39  * Connect a probe to a tracepoint.
 40  * Internal API, should not be used directly.
 41  */
 42 extern int tracepoint_probe_register(const char *name, void *probe, void *data);
 43 
 44 /*
 45  * Disconnect a probe from a tracepoint.
 46  * Internal API, should not be used directly.
 47  */
 48 extern int
 49 tracepoint_probe_unregister(const char *name, void *probe, void *data);
 50 
 51 extern int tracepoint_probe_register_noupdate(const char *name, void *probe,
 52                                               void *data);
 53 extern int tracepoint_probe_unregister_noupdate(const char *name, void *probe,
 54                                                 void *data);
 55 extern void tracepoint_probe_update_all(void);
 56 
 57 #ifdef CONFIG_MODULES
 58 struct tp_module {
 59         struct list_head list;
 60         unsigned int num_tracepoints;
 61         struct tracepoint * const *tracepoints_ptrs;
 62 };
 63 #endif /* CONFIG_MODULES */
 64 
 65 struct tracepoint_iter {
 66 #ifdef CONFIG_MODULES
 67         struct tp_module *module;
 68 #endif /* CONFIG_MODULES */
 69         struct tracepoint * const *tracepoint;
 70 };
 71 
 72 extern void tracepoint_iter_start(struct tracepoint_iter *iter);
 73 extern void tracepoint_iter_next(struct tracepoint_iter *iter);
 74 extern void tracepoint_iter_stop(struct tracepoint_iter *iter);
 75 extern void tracepoint_iter_reset(struct tracepoint_iter *iter);
 76 
 77 /*
 78  * tracepoint_synchronize_unregister must be called between the last tracepoint
 79  * probe unregistration and the end of module exit to make sure there is no
 80  * caller executing a probe when it is freed.
 81  */
 82 static inline void tracepoint_synchronize_unregister(void)
 83 {
 84         synchronize_sched();
 85 }
 86 
 87 #define PARAMS(args...) args
 88 
 89 #endif /* _LINUX_TRACEPOINT_H */
 90 
 91 /*
 92  * Note: we keep the TRACE_EVENT and DECLARE_TRACE outside the include
 93  *  file ifdef protection.
 94  *  This is due to the way trace events work. If a file includes two
 95  *  trace event headers under one "CREATE_TRACE_POINTS" the first include
 96  *  will override the TRACE_EVENT and break the second include.
 97  */
 98 
 99 #ifndef DECLARE_TRACE
100 
101 #define TP_PROTO(args...)       args
102 #define TP_ARGS(args...)        args
103 #define TP_CONDITION(args...)   args
104 
105 #ifdef CONFIG_TRACEPOINTS
106 
107 /*
108  * it_func[0] is never NULL because there is at least one element in the array
109  * when the array itself is non NULL.
110  *
111  * Note, the proto and args passed in includes "__data" as the first parameter.
112  * The reason for this is to handle the "void" prototype. If a tracepoint
113  * has a "void" prototype, then it is invalid to declare a function
114  * as "(void *, void)". The DECLARE_TRACE_NOARGS() will pass in just
115  * "void *data", where as the DECLARE_TRACE() will pass in "void *data, proto".
116  */
117 #define __DO_TRACE(tp, proto, args, cond)                               \
118         do {                                                            \
119                 struct tracepoint_func *it_func_ptr;                    \
120                 void *it_func;                                          \
121                 void *__data;                                           \
122                                                                         \
123                 if (!(cond))                                            \
124                         return;                                         \
125                 rcu_read_lock_sched_notrace();                          \
126                 it_func_ptr = rcu_dereference_sched((tp)->funcs);       \
127                 if (it_func_ptr) {                                      \
128                         do {                                            \
129                                 it_func = (it_func_ptr)->func;          \
130                                 __data = (it_func_ptr)->data;           \
131                                 ((void(*)(proto))(it_func))(args);      \
132                         } while ((++it_func_ptr)->func);                \
133                 }                                                       \
134                 rcu_read_unlock_sched_notrace();                        \
135         } while (0)
136 
137 /*
138  * Make sure the alignment of the structure in the __tracepoints section will
139  * not add unwanted padding between the beginning of the section and the
140  * structure. Force alignment to the same alignment as the section start.
141  */
142 #define __DECLARE_TRACE(name, proto, args, cond, data_proto, data_args) \
143         extern struct tracepoint __tracepoint_##name;                   \
144         static inline void trace_##name(proto)                          \
145         {                                                               \
146                 if (static_branch(&__tracepoint_##name.key))            \
147                         __DO_TRACE(&__tracepoint_##name,                \
148                                 TP_PROTO(data_proto),                   \
149                                 TP_ARGS(data_args),                     \
150                                 TP_CONDITION(cond));                    \
151         }                                                               \
152         static inline int                                               \
153         register_trace_##name(void (*probe)(data_proto), void *data)    \
154         {                                                               \
155                 return tracepoint_probe_register(#name, (void *)probe,  \
156                                                  data);                 \
157         }                                                               \
158         static inline int                                               \
159         unregister_trace_##name(void (*probe)(data_proto), void *data)  \
160         {                                                               \
161                 return tracepoint_probe_unregister(#name, (void *)probe, \
162                                                    data);               \
163         }                                                               \
164         static inline void                                              \
165         check_trace_callback_type_##name(void (*cb)(data_proto))        \
166         {                                                               \
167         }
168 
169 /*
170  * We have no guarantee that gcc and the linker won't up-align the tracepoint
171  * structures, so we create an array of pointers that will be used for iteration
172  * on the tracepoints.
173  */
174 #define DEFINE_TRACE_FN(name, reg, unreg)                                \
175         static const char __tpstrtab_##name[]                            \
176         __attribute__((section("__tracepoints_strings"))) = #name;       \
177         struct tracepoint __tracepoint_##name                            \
178         __attribute__((section("__tracepoints"))) =                      \
179                 { __tpstrtab_##name, JUMP_LABEL_INIT, reg, unreg, NULL };\
180         static struct tracepoint * const __tracepoint_ptr_##name __used  \
181         __attribute__((section("__tracepoints_ptrs"))) =                 \
182                 &__tracepoint_##name;
183 
184 #define DEFINE_TRACE(name)                                              \
185         DEFINE_TRACE_FN(name, NULL, NULL);
186 
187 #define EXPORT_TRACEPOINT_SYMBOL_GPL(name)                              \
188         EXPORT_SYMBOL_GPL(__tracepoint_##name)
189 #define EXPORT_TRACEPOINT_SYMBOL(name)                                  \
190         EXPORT_SYMBOL(__tracepoint_##name)
191 
192 #else /* !CONFIG_TRACEPOINTS */
193 #define __DECLARE_TRACE(name, proto, args, cond, data_proto, data_args) \
194         static inline void trace_##name(proto)                          \
195         { }                                                             \
196         static inline int                                               \
197         register_trace_##name(void (*probe)(data_proto),                \
198                               void *data)                               \
199         {                                                               \
200                 return -ENOSYS;                                         \
201         }                                                               \
202         static inline int                                               \
203         unregister_trace_##name(void (*probe)(data_proto),              \
204                                 void *data)                             \
205         {                                                               \
206                 return -ENOSYS;                                         \
207         }                                                               \
208         static inline void check_trace_callback_type_##name(void (*cb)(data_proto)) \
209         {                                                               \
210         }
211 
212 #define DEFINE_TRACE_FN(name, reg, unreg)
213 #define DEFINE_TRACE(name)
214 #define EXPORT_TRACEPOINT_SYMBOL_GPL(name)
215 #define EXPORT_TRACEPOINT_SYMBOL(name)
216 
217 #endif /* CONFIG_TRACEPOINTS */
218 
219 /*
220  * The need for the DECLARE_TRACE_NOARGS() is to handle the prototype
221  * (void). "void" is a special value in a function prototype and can
222  * not be combined with other arguments. Since the DECLARE_TRACE()
223  * macro adds a data element at the beginning of the prototype,
224  * we need a way to differentiate "(void *data, proto)" from
225  * "(void *data, void)". The second prototype is invalid.
226  *
227  * DECLARE_TRACE_NOARGS() passes "void" as the tracepoint prototype
228  * and "void *__data" as the callback prototype.
229  *
230  * DECLARE_TRACE() passes "proto" as the tracepoint protoype and
231  * "void *__data, proto" as the callback prototype.
232  */
233 #define DECLARE_TRACE_NOARGS(name)                                      \
234                 __DECLARE_TRACE(name, void, , 1, void *__data, __data)
235 
236 #define DECLARE_TRACE(name, proto, args)                                \
237                 __DECLARE_TRACE(name, PARAMS(proto), PARAMS(args), 1,   \
238                                 PARAMS(void *__data, proto),            \
239                                 PARAMS(__data, args))
240 
241 #define DECLARE_TRACE_CONDITION(name, proto, args, cond)                \
242         __DECLARE_TRACE(name, PARAMS(proto), PARAMS(args), PARAMS(cond), \
243                         PARAMS(void *__data, proto),                    \
244                         PARAMS(__data, args))
245 
246 #define TRACE_EVENT_FLAGS(event, flag)
247 
248 #endif /* DECLARE_TRACE */
249 
250 #ifndef TRACE_EVENT
251 /*
252  * For use with the TRACE_EVENT macro:
253  *
254  * We define a tracepoint, its arguments, its printk format
255  * and its 'fast binay record' layout.
256  *
257  * Firstly, name your tracepoint via TRACE_EVENT(name : the
258  * 'subsystem_event' notation is fine.
259  *
260  * Think about this whole construct as the
261  * 'trace_sched_switch() function' from now on.
262  *
263  *
264  *  TRACE_EVENT(sched_switch,
265  *
266  *      *
267  *      * A function has a regular function arguments
268  *      * prototype, declare it via TP_PROTO():
269  *      *
270  *
271  *      TP_PROTO(struct rq *rq, struct task_struct *prev,
272  *               struct task_struct *next),
273  *
274  *      *
275  *      * Define the call signature of the 'function'.
276  *      * (Design sidenote: we use this instead of a
277  *      *  TP_PROTO1/TP_PROTO2/TP_PROTO3 ugliness.)
278  *      *
279  *
280  *      TP_ARGS(rq, prev, next),
281  *
282  *      *
283  *      * Fast binary tracing: define the trace record via
284  *      * TP_STRUCT__entry(). You can think about it like a
285  *      * regular C structure local variable definition.
286  *      *
287  *      * This is how the trace record is structured and will
288  *      * be saved into the ring buffer. These are the fields
289  *      * that will be exposed to user-space in
290  *      * /sys/kernel/debug/tracing/events/<*>/format.
291  *      *
292  *      * The declared 'local variable' is called '__entry'
293  *      *
294  *      * __field(pid_t, prev_prid) is equivalent to a standard declariton:
295  *      *
296  *      *       pid_t   prev_pid;
297  *      *
298  *      * __array(char, prev_comm, TASK_COMM_LEN) is equivalent to:
299  *      *
300  *      *       char    prev_comm[TASK_COMM_LEN];
301  *      *
302  *
303  *      TP_STRUCT__entry(
304  *              __array(        char,   prev_comm,      TASK_COMM_LEN   )
305  *              __field(        pid_t,  prev_pid                        )
306  *              __field(        int,    prev_prio                       )
307  *              __array(        char,   next_comm,      TASK_COMM_LEN   )
308  *              __field(        pid_t,  next_pid                        )
309  *              __field(        int,    next_prio                       )
310  *      ),
311  *
312  *      *
313  *      * Assign the entry into the trace record, by embedding
314  *      * a full C statement block into TP_fast_assign(). You
315  *      * can refer to the trace record as '__entry' -
316  *      * otherwise you can put arbitrary C code in here.
317  *      *
318  *      * Note: this C code will execute every time a trace event
319  *      * happens, on an active tracepoint.
320  *      *
321  *
322  *      TP_fast_assign(
323  *              memcpy(__entry->next_comm, next->comm, TASK_COMM_LEN);
324  *              __entry->prev_pid       = prev->pid;
325  *              __entry->prev_prio      = prev->prio;
326  *              memcpy(__entry->prev_comm, prev->comm, TASK_COMM_LEN);
327  *              __entry->next_pid       = next->pid;
328  *              __entry->next_prio      = next->prio;
329  *      ),
330  *
331  *      *
332  *      * Formatted output of a trace record via TP_printk().
333  *      * This is how the tracepoint will appear under ftrace
334  *      * plugins that make use of this tracepoint.
335  *      *
336  *      * (raw-binary tracing wont actually perform this step.)
337  *      *
338  *
339  *      TP_printk("task %s:%d [%d] ==> %s:%d [%d]",
340  *              __entry->prev_comm, __entry->prev_pid, __entry->prev_prio,
341  *              __entry->next_comm, __entry->next_pid, __entry->next_prio),
342  *
343  * );
344  *
345  * This macro construct is thus used for the regular printk format
346  * tracing setup, it is used to construct a function pointer based
347  * tracepoint callback (this is used by programmatic plugins and
348  * can also by used by generic instrumentation like SystemTap), and
349  * it is also used to expose a structured trace record in
350  * /sys/kernel/debug/tracing/events/.
351  *
352  * A set of (un)registration functions can be passed to the variant
353  * TRACE_EVENT_FN to perform any (un)registration work.
354  */
355 
356 #define DECLARE_EVENT_CLASS(name, proto, args, tstruct, assign, print)
357 #define DEFINE_EVENT(template, name, proto, args)               \
358         DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))
359 #define DEFINE_EVENT_PRINT(template, name, proto, args, print)  \
360         DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))
361 #define DEFINE_EVENT_CONDITION(template, name, proto,           \
362                                args, cond)                      \
363         DECLARE_TRACE_CONDITION(name, PARAMS(proto),            \
364                                 PARAMS(args), PARAMS(cond))
365 
366 #define TRACE_EVENT(name, proto, args, struct, assign, print)   \
367         DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))
368 #define TRACE_EVENT_FN(name, proto, args, struct,               \
369                 assign, print, reg, unreg)                      \
370         DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))
371 #define TRACE_EVENT_CONDITION(name, proto, args, cond,          \
372                               struct, assign, print)            \
373         DECLARE_TRACE_CONDITION(name, PARAMS(proto),            \
374                                 PARAMS(args), PARAMS(cond))
375 
376 #define TRACE_EVENT_FLAGS(event, flag)
377 
378 #endif /* ifdef TRACE_EVENT (see note above) */
379 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp