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