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

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

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

~ [ 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