1/* SPDX-License-Identifier: GPL-2.0 */
 2#ifndef TRACEPOINT_DEFS_H
 3#define TRACEPOINT_DEFS_H 1
 4
 5/*
 6 * File can be included directly by headers who only want to access
 7 * tracepoint->key to guard out of line trace calls, or the definition of
 8 * trace_print_flags{_u64}. Otherwise linux/tracepoint.h should be used.
 9 */
10
11#include <linux/atomic.h>
12#include <linux/static_key.h>
13
 
 
14struct trace_print_flags {
15	unsigned long		mask;
16	const char		*name;
17};
18
19struct trace_print_flags_u64 {
20	unsigned long long	mask;
21	const char		*name;
22};
23
24struct tracepoint_func {
25	void *func;
26	void *data;
27	int prio;
28};
29
30struct tracepoint {
31	const char *name;		/* Tracepoint name */
32	struct static_key key;
 
 
 
 
33	int (*regfunc)(void);
34	void (*unregfunc)(void);
35	struct tracepoint_func __rcu *funcs;
36};
37
38#ifdef CONFIG_HAVE_ARCH_PREL32_RELOCATIONS
39typedef const int tracepoint_ptr_t;
40#else
41typedef struct tracepoint * const tracepoint_ptr_t;
42#endif
43
44struct bpf_raw_event_map {
45	struct tracepoint	*tp;
46	void			*bpf_func;
47	u32			num_args;
48	u32			writable_size;
49} __aligned(32);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
50
51#endif

 1/* SPDX-License-Identifier: GPL-2.0 */
 2#ifndef TRACEPOINT_DEFS_H
 3#define TRACEPOINT_DEFS_H 1
 4
 5/*
 6 * File can be included directly by headers who only want to access
 7 * tracepoint->key to guard out of line trace calls, or the definition of
 8 * trace_print_flags{_u64}. Otherwise linux/tracepoint.h should be used.
 9 */
10
11#include <linux/atomic.h>
12#include <linux/static_key.h>
13
14struct static_call_key;
15
16struct trace_print_flags {
17	unsigned long		mask;
18	const char		*name;
19};
20
21struct trace_print_flags_u64 {
22	unsigned long long	mask;
23	const char		*name;
24};
25
26struct tracepoint_func {
27	void *func;
28	void *data;
29	int prio;
30};
31
32struct tracepoint {
33	const char *name;		/* Tracepoint name */
34	struct static_key key;
35	struct static_call_key *static_call_key;
36	void *static_call_tramp;
37	void *iterator;
38	void *probestub;
39	int (*regfunc)(void);
40	void (*unregfunc)(void);
41	struct tracepoint_func __rcu *funcs;
42};
43
44#ifdef CONFIG_HAVE_ARCH_PREL32_RELOCATIONS
45typedef const int tracepoint_ptr_t;
46#else
47typedef struct tracepoint * const tracepoint_ptr_t;
48#endif
49
50struct bpf_raw_event_map {
51	struct tracepoint	*tp;
52	void			*bpf_func;
53	u32			num_args;
54	u32			writable_size;
55} __aligned(32);
56
57/*
58 * If a tracepoint needs to be called from a header file, it is not
59 * recommended to call it directly, as tracepoints in header files
60 * may cause side-effects and bloat the kernel. Instead, use
61 * tracepoint_enabled() to test if the tracepoint is enabled, then if
62 * it is, call a wrapper function defined in a C file that will then
63 * call the tracepoint.
64 *
65 * For "trace_foo_bar()", you would need to create a wrapper function
66 * in a C file to call trace_foo_bar():
67 *   void do_trace_foo_bar(args) { trace_foo_bar(args); }
68 * Then in the header file, declare the tracepoint:
69 *   DECLARE_TRACEPOINT(foo_bar);
70 * And call your wrapper:
71 *   static inline void some_inlined_function() {
72 *            [..]
73 *            if (tracepoint_enabled(foo_bar))
74 *                    do_trace_foo_bar(args);
75 *            [..]
76 *   }
77 *
78 * Note: tracepoint_enabled(foo_bar) is equivalent to trace_foo_bar_enabled()
79 *   but is safe to have in headers, where trace_foo_bar_enabled() is not.
80 */
81#define DECLARE_TRACEPOINT(tp) \
82	extern struct tracepoint __tracepoint_##tp
83
84#ifdef CONFIG_TRACEPOINTS
85# define tracepoint_enabled(tp) \
86	static_key_false(&(__tracepoint_##tp).key)
87#else
88# define tracepoint_enabled(tracepoint) false
89#endif
90
91#endif