1 /* SPDX-License-Identifier: GPL-2.0-only */
2 #ifndef _LINUX_TRACEPOINT_H
3 #define _LINUX_TRACEPOINT_H
6 * Kernel Tracepoint API.
8 * See Documentation/trace/tracepoints.rst.
10 * Copyright (C) 2008-2014 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
12 * Heavily inspired from the Linux Kernel Markers.
15 #include <linux/smp.h>
16 #include <linux/srcu.h>
17 #include <linux/errno.h>
18 #include <linux/types.h>
19 #include <linux/cpumask.h>
20 #include <linux/rcupdate.h>
21 #include <linux/tracepoint-defs.h>
25 struct notifier_block
;
27 struct trace_eval_map
{
29 const char *eval_string
;
30 unsigned long eval_value
;
33 #define TRACEPOINT_DEFAULT_PRIO 10
35 extern struct srcu_struct tracepoint_srcu
;
38 tracepoint_probe_register(struct tracepoint
*tp
, void *probe
, void *data
);
40 tracepoint_probe_register_prio(struct tracepoint
*tp
, void *probe
, void *data
,
43 tracepoint_probe_unregister(struct tracepoint
*tp
, void *probe
, void *data
);
45 for_each_kernel_tracepoint(void (*fct
)(struct tracepoint
*tp
, void *priv
),
50 struct list_head list
;
54 bool trace_module_has_bad_taint(struct module
*mod
);
55 extern int register_tracepoint_module_notifier(struct notifier_block
*nb
);
56 extern int unregister_tracepoint_module_notifier(struct notifier_block
*nb
);
58 static inline bool trace_module_has_bad_taint(struct module
*mod
)
63 int register_tracepoint_module_notifier(struct notifier_block
*nb
)
68 int unregister_tracepoint_module_notifier(struct notifier_block
*nb
)
72 #endif /* CONFIG_MODULES */
75 * tracepoint_synchronize_unregister must be called between the last tracepoint
76 * probe unregistration and the end of module exit to make sure there is no
77 * caller executing a probe when it is freed.
79 #ifdef CONFIG_TRACEPOINTS
80 static inline void tracepoint_synchronize_unregister(void)
82 synchronize_srcu(&tracepoint_srcu
);
86 static inline void tracepoint_synchronize_unregister(void)
90 #ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS
91 extern int syscall_regfunc(void);
92 extern void syscall_unregfunc(void);
93 #endif /* CONFIG_HAVE_SYSCALL_TRACEPOINTS */
95 #define PARAMS(args...) args
97 #define TRACE_DEFINE_ENUM(x)
98 #define TRACE_DEFINE_SIZEOF(x)
100 #ifdef CONFIG_HAVE_ARCH_PREL32_RELOCATIONS
101 static inline struct tracepoint
*tracepoint_ptr_deref(tracepoint_ptr_t
*p
)
103 return offset_to_ptr(p
);
106 #define __TRACEPOINT_ENTRY(name) \
107 asm(" .section \"__tracepoints_ptrs\", \"a\" \n" \
109 " .long __tracepoint_" #name " - . \n" \
112 static inline struct tracepoint
*tracepoint_ptr_deref(tracepoint_ptr_t
*p
)
117 #define __TRACEPOINT_ENTRY(name) \
118 static tracepoint_ptr_t __tracepoint_ptr_##name __used \
119 __attribute__((section("__tracepoints_ptrs"))) = \
123 #endif /* _LINUX_TRACEPOINT_H */
126 * Note: we keep the TRACE_EVENT and DECLARE_TRACE outside the include
127 * file ifdef protection.
128 * This is due to the way trace events work. If a file includes two
129 * trace event headers under one "CREATE_TRACE_POINTS" the first include
130 * will override the TRACE_EVENT and break the second include.
133 #ifndef DECLARE_TRACE
135 #define TP_PROTO(args...) args
136 #define TP_ARGS(args...) args
137 #define TP_CONDITION(args...) args
140 * Individual subsystem my have a separate configuration to
141 * enable their tracepoints. By default, this file will create
142 * the tracepoints if CONFIG_TRACEPOINT is defined. If a subsystem
143 * wants to be able to disable its tracepoints from being created
144 * it can define NOTRACE before including the tracepoint headers.
146 #if defined(CONFIG_TRACEPOINTS) && !defined(NOTRACE)
147 #define TRACEPOINTS_ENABLED
150 #ifdef TRACEPOINTS_ENABLED
153 * it_func[0] is never NULL because there is at least one element in the array
154 * when the array itself is non NULL.
156 * Note, the proto and args passed in includes "__data" as the first parameter.
157 * The reason for this is to handle the "void" prototype. If a tracepoint
158 * has a "void" prototype, then it is invalid to declare a function
159 * as "(void *, void)".
161 #define __DO_TRACE(tp, proto, args, cond, rcuidle) \
163 struct tracepoint_func *it_func_ptr; \
166 int __maybe_unused __idx = 0; \
171 /* srcu can't be used from NMI */ \
172 WARN_ON_ONCE(rcuidle && in_nmi()); \
174 /* keep srcu and sched-rcu usage consistent */ \
175 preempt_disable_notrace(); \
178 * For rcuidle callers, use srcu since sched-rcu \
179 * doesn't work from the idle path. \
182 __idx = srcu_read_lock_notrace(&tracepoint_srcu);\
183 rcu_irq_enter_irqson(); \
186 it_func_ptr = rcu_dereference_raw((tp)->funcs); \
190 it_func = (it_func_ptr)->func; \
191 __data = (it_func_ptr)->data; \
192 ((void(*)(proto))(it_func))(args); \
193 } while ((++it_func_ptr)->func); \
197 rcu_irq_exit_irqson(); \
198 srcu_read_unlock_notrace(&tracepoint_srcu, __idx);\
201 preempt_enable_notrace(); \
205 #define __DECLARE_TRACE_RCU(name, proto, args, cond, data_proto, data_args) \
206 static inline void trace_##name##_rcuidle(proto) \
208 if (static_key_false(&__tracepoint_##name.key)) \
209 __DO_TRACE(&__tracepoint_##name, \
210 TP_PROTO(data_proto), \
211 TP_ARGS(data_args), \
212 TP_CONDITION(cond), 1); \
215 #define __DECLARE_TRACE_RCU(name, proto, args, cond, data_proto, data_args)
219 * Make sure the alignment of the structure in the __tracepoints section will
220 * not add unwanted padding between the beginning of the section and the
221 * structure. Force alignment to the same alignment as the section start.
223 * When lockdep is enabled, we make sure to always do the RCU portions of
224 * the tracepoint code, regardless of whether tracing is on. However,
225 * don't check if the condition is false, due to interaction with idle
226 * instrumentation. This lets us find RCU issues triggered with tracepoints
227 * even when this tracepoint is off. This code has no purpose other than
230 #define __DECLARE_TRACE(name, proto, args, cond, data_proto, data_args) \
231 extern struct tracepoint __tracepoint_##name; \
232 static inline void trace_##name(proto) \
234 if (static_key_false(&__tracepoint_##name.key)) \
235 __DO_TRACE(&__tracepoint_##name, \
236 TP_PROTO(data_proto), \
237 TP_ARGS(data_args), \
238 TP_CONDITION(cond), 0); \
239 if (IS_ENABLED(CONFIG_LOCKDEP) && (cond)) { \
240 rcu_read_lock_sched_notrace(); \
241 rcu_dereference_sched(__tracepoint_##name.funcs);\
242 rcu_read_unlock_sched_notrace(); \
245 __DECLARE_TRACE_RCU(name, PARAMS(proto), PARAMS(args), \
246 PARAMS(cond), PARAMS(data_proto), PARAMS(data_args)) \
248 register_trace_##name(void (*probe)(data_proto), void *data) \
250 return tracepoint_probe_register(&__tracepoint_##name, \
251 (void *)probe, data); \
254 register_trace_prio_##name(void (*probe)(data_proto), void *data,\
257 return tracepoint_probe_register_prio(&__tracepoint_##name, \
258 (void *)probe, data, prio); \
261 unregister_trace_##name(void (*probe)(data_proto), void *data) \
263 return tracepoint_probe_unregister(&__tracepoint_##name,\
264 (void *)probe, data); \
267 check_trace_callback_type_##name(void (*cb)(data_proto)) \
271 trace_##name##_enabled(void) \
273 return static_key_false(&__tracepoint_##name.key); \
277 * We have no guarantee that gcc and the linker won't up-align the tracepoint
278 * structures, so we create an array of pointers that will be used for iteration
279 * on the tracepoints.
281 #define DEFINE_TRACE_FN(name, reg, unreg) \
282 static const char __tpstrtab_##name[] \
283 __attribute__((section("__tracepoints_strings"))) = #name; \
284 struct tracepoint __tracepoint_##name \
285 __attribute__((section("__tracepoints"), used)) = \
286 { __tpstrtab_##name, STATIC_KEY_INIT_FALSE, reg, unreg, NULL };\
287 __TRACEPOINT_ENTRY(name);
289 #define DEFINE_TRACE(name) \
290 DEFINE_TRACE_FN(name, NULL, NULL);
292 #define EXPORT_TRACEPOINT_SYMBOL_GPL(name) \
293 EXPORT_SYMBOL_GPL(__tracepoint_##name)
294 #define EXPORT_TRACEPOINT_SYMBOL(name) \
295 EXPORT_SYMBOL(__tracepoint_##name)
297 #else /* !TRACEPOINTS_ENABLED */
298 #define __DECLARE_TRACE(name, proto, args, cond, data_proto, data_args) \
299 static inline void trace_##name(proto) \
301 static inline void trace_##name##_rcuidle(proto) \
304 register_trace_##name(void (*probe)(data_proto), \
310 unregister_trace_##name(void (*probe)(data_proto), \
315 static inline void check_trace_callback_type_##name(void (*cb)(data_proto)) \
319 trace_##name##_enabled(void) \
324 #define DEFINE_TRACE_FN(name, reg, unreg)
325 #define DEFINE_TRACE(name)
326 #define EXPORT_TRACEPOINT_SYMBOL_GPL(name)
327 #define EXPORT_TRACEPOINT_SYMBOL(name)
329 #endif /* TRACEPOINTS_ENABLED */
331 #ifdef CONFIG_TRACING
333 * tracepoint_string - register constant persistent string to trace system
334 * @str - a constant persistent string that will be referenced in tracepoints
336 * If constant strings are being used in tracepoints, it is faster and
337 * more efficient to just save the pointer to the string and reference
338 * that with a printf "%s" instead of saving the string in the ring buffer
339 * and wasting space and time.
341 * The problem with the above approach is that userspace tools that read
342 * the binary output of the trace buffers do not have access to the string.
343 * Instead they just show the address of the string which is not very
346 * With tracepoint_string(), the string will be registered to the tracing
347 * system and exported to userspace via the debugfs/tracing/printk_formats
348 * file that maps the string address to the string text. This way userspace
349 * tools that read the binary buffers have a way to map the pointers to
350 * the ASCII strings they represent.
352 * The @str used must be a constant string and persistent as it would not
353 * make sense to show a string that no longer exists. But it is still fine
354 * to be used with modules, because when modules are unloaded, if they
355 * had tracepoints, the ring buffers are cleared too. As long as the string
356 * does not change during the life of the module, it is fine to use
357 * tracepoint_string() within a module.
359 #define tracepoint_string(str) \
361 static const char *___tp_str __tracepoint_string = str; \
364 #define __tracepoint_string __attribute__((section("__tracepoint_str")))
367 * tracepoint_string() is used to save the string address for userspace
368 * tracing tools. When tracing isn't configured, there's no need to save
371 # define tracepoint_string(str) str
372 # define __tracepoint_string
375 #define DECLARE_TRACE(name, proto, args) \
376 __DECLARE_TRACE(name, PARAMS(proto), PARAMS(args), \
377 cpu_online(raw_smp_processor_id()), \
378 PARAMS(void *__data, proto), \
379 PARAMS(__data, args))
381 #define DECLARE_TRACE_CONDITION(name, proto, args, cond) \
382 __DECLARE_TRACE(name, PARAMS(proto), PARAMS(args), \
383 cpu_online(raw_smp_processor_id()) && (PARAMS(cond)), \
384 PARAMS(void *__data, proto), \
385 PARAMS(__data, args))
387 #define TRACE_EVENT_FLAGS(event, flag)
389 #define TRACE_EVENT_PERF_PERM(event, expr...)
391 #endif /* DECLARE_TRACE */
395 * For use with the TRACE_EVENT macro:
397 * We define a tracepoint, its arguments, its printk format
398 * and its 'fast binary record' layout.
400 * Firstly, name your tracepoint via TRACE_EVENT(name : the
401 * 'subsystem_event' notation is fine.
403 * Think about this whole construct as the
404 * 'trace_sched_switch() function' from now on.
407 * TRACE_EVENT(sched_switch,
410 * * A function has a regular function arguments
411 * * prototype, declare it via TP_PROTO():
414 * TP_PROTO(struct rq *rq, struct task_struct *prev,
415 * struct task_struct *next),
418 * * Define the call signature of the 'function'.
419 * * (Design sidenote: we use this instead of a
420 * * TP_PROTO1/TP_PROTO2/TP_PROTO3 ugliness.)
423 * TP_ARGS(rq, prev, next),
426 * * Fast binary tracing: define the trace record via
427 * * TP_STRUCT__entry(). You can think about it like a
428 * * regular C structure local variable definition.
430 * * This is how the trace record is structured and will
431 * * be saved into the ring buffer. These are the fields
432 * * that will be exposed to user-space in
433 * * /sys/kernel/debug/tracing/events/<*>/format.
435 * * The declared 'local variable' is called '__entry'
437 * * __field(pid_t, prev_prid) is equivalent to a standard declariton:
441 * * __array(char, prev_comm, TASK_COMM_LEN) is equivalent to:
443 * * char prev_comm[TASK_COMM_LEN];
447 * __array( char, prev_comm, TASK_COMM_LEN )
448 * __field( pid_t, prev_pid )
449 * __field( int, prev_prio )
450 * __array( char, next_comm, TASK_COMM_LEN )
451 * __field( pid_t, next_pid )
452 * __field( int, next_prio )
456 * * Assign the entry into the trace record, by embedding
457 * * a full C statement block into TP_fast_assign(). You
458 * * can refer to the trace record as '__entry' -
459 * * otherwise you can put arbitrary C code in here.
461 * * Note: this C code will execute every time a trace event
462 * * happens, on an active tracepoint.
466 * memcpy(__entry->next_comm, next->comm, TASK_COMM_LEN);
467 * __entry->prev_pid = prev->pid;
468 * __entry->prev_prio = prev->prio;
469 * memcpy(__entry->prev_comm, prev->comm, TASK_COMM_LEN);
470 * __entry->next_pid = next->pid;
471 * __entry->next_prio = next->prio;
475 * * Formatted output of a trace record via TP_printk().
476 * * This is how the tracepoint will appear under ftrace
477 * * plugins that make use of this tracepoint.
479 * * (raw-binary tracing wont actually perform this step.)
482 * TP_printk("task %s:%d [%d] ==> %s:%d [%d]",
483 * __entry->prev_comm, __entry->prev_pid, __entry->prev_prio,
484 * __entry->next_comm, __entry->next_pid, __entry->next_prio),
488 * This macro construct is thus used for the regular printk format
489 * tracing setup, it is used to construct a function pointer based
490 * tracepoint callback (this is used by programmatic plugins and
491 * can also by used by generic instrumentation like SystemTap), and
492 * it is also used to expose a structured trace record in
493 * /sys/kernel/debug/tracing/events/.
495 * A set of (un)registration functions can be passed to the variant
496 * TRACE_EVENT_FN to perform any (un)registration work.
499 #define DECLARE_EVENT_CLASS(name, proto, args, tstruct, assign, print)
500 #define DEFINE_EVENT(template, name, proto, args) \
501 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))
502 #define DEFINE_EVENT_FN(template, name, proto, args, reg, unreg)\
503 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))
504 #define DEFINE_EVENT_PRINT(template, name, proto, args, print) \
505 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))
506 #define DEFINE_EVENT_CONDITION(template, name, proto, \
508 DECLARE_TRACE_CONDITION(name, PARAMS(proto), \
509 PARAMS(args), PARAMS(cond))
511 #define TRACE_EVENT(name, proto, args, struct, assign, print) \
512 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))
513 #define TRACE_EVENT_FN(name, proto, args, struct, \
514 assign, print, reg, unreg) \
515 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))
516 #define TRACE_EVENT_FN_COND(name, proto, args, cond, struct, \
517 assign, print, reg, unreg) \
518 DECLARE_TRACE_CONDITION(name, PARAMS(proto), \
519 PARAMS(args), PARAMS(cond))
520 #define TRACE_EVENT_CONDITION(name, proto, args, cond, \
521 struct, assign, print) \
522 DECLARE_TRACE_CONDITION(name, PARAMS(proto), \
523 PARAMS(args), PARAMS(cond))
525 #define TRACE_EVENT_FLAGS(event, flag)
527 #define TRACE_EVENT_PERF_PERM(event, expr...)
529 #define DECLARE_EVENT_NOP(name, proto, args) \
530 static inline void trace_##name(proto) \
532 static inline bool trace_##name##_enabled(void) \
537 #define TRACE_EVENT_NOP(name, proto, args, struct, assign, print) \
538 DECLARE_EVENT_NOP(name, PARAMS(proto), PARAMS(args))
540 #define DECLARE_EVENT_CLASS_NOP(name, proto, args, tstruct, assign, print)
541 #define DEFINE_EVENT_NOP(template, name, proto, args) \
542 DECLARE_EVENT_NOP(name, PARAMS(proto), PARAMS(args))
544 #endif /* ifdef TRACE_EVENT (see note above) */