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