include/linux/tracepoint-defs.h

   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
  14 struct static_call_key;
  15
  16 struct trace_print_flags {
  17         unsigned long           mask;
  18         const char              *name;
  19 };
  20
  21 struct trace_print_flags_u64 {
  22         unsigned long long      mask;
  23         const char              *name;
  24 };
  25
  26 struct tracepoint_func {
  27         void *func;
  28         void *data;
  29         int prio;
  30 };
  31
  32 struct 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         int (*regfunc)(void);
  39         void (*unregfunc)(void);
  40         struct tracepoint_func __rcu *funcs;
  41 };
  42
  43 #ifdef CONFIG_HAVE_ARCH_PREL32_RELOCATIONS
  44 typedef const int tracepoint_ptr_t;
  45 #else
  46 typedef struct tracepoint * const tracepoint_ptr_t;
  47 #endif
  48
  49 struct bpf_raw_event_map {
  50         struct tracepoint       *tp;
  51         void                    *bpf_func;
  52         u32                     num_args;
  53         u32                     writable_size;
  54 } __aligned(32);
  55
  56 /*
  57  * If a tracepoint needs to be called from a header file, it is not
  58  * recommended to call it directly, as tracepoints in header files
  59  * may cause side-effects and bloat the kernel. Instead, use
  60  * tracepoint_enabled() to test if the tracepoint is enabled, then if
  61  * it is, call a wrapper function defined in a C file that will then
  62  * call the tracepoint.
  63  *
  64  * For "trace_foo_bar()", you would need to create a wrapper function
  65  * in a C file to call trace_foo_bar():
  66  *   void do_trace_foo_bar(args) { trace_foo_bar(args); }
  67  * Then in the header file, declare the tracepoint:
  68  *   DECLARE_TRACEPOINT(foo_bar);
  69  * And call your wrapper:
  70  *   static inline void some_inlined_function() {
  71  *            [..]
  72  *            if (tracepoint_enabled(foo_bar))
  73  *                    do_trace_foo_bar(args);
  74  *            [..]
  75  *   }
  76  *
  77  * Note: tracepoint_enabled(foo_bar) is equivalent to trace_foo_bar_enabled()
  78  *   but is safe to have in headers, where trace_foo_bar_enabled() is not.
  79  */
  80 #define DECLARE_TRACEPOINT(tp) \
  81         extern struct tracepoint __tracepoint_##tp
  82
  83 #ifdef CONFIG_TRACEPOINTS
  84 # define tracepoint_enabled(tp) \
  85         static_key_false(&(__tracepoint_##tp).key)
  86 #else
  87 # define tracepoint_enabled(tracepoint) false
  88 #endif
  89
  90 #endif