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 * Copyright (C) 2008-2014 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/static_key.h> 21 22 struct module; 23 struct tracepoint; 24 struct notifier_block; 25 26 struct tracepoint_func { 27 void *func; 28 void *data; 29 }; 30 31 struct tracepoint { 32 const char *name; /* Tracepoint name */ 33 struct static_key key; 34 void (*regfunc)(void); 35 void (*unregfunc)(void); 36 struct tracepoint_func __rcu *funcs; 37 }; 38 39 extern int 40 tracepoint_probe_register(struct tracepoint *tp, void *probe, void *data); 41 extern int 42 tracepoint_probe_unregister(struct tracepoint *tp, void *probe, void *data); 43 extern void 44 for_each_kernel_tracepoint(void (*fct)(struct tracepoint *tp, void *priv), 45 void *priv); 46 47 #ifdef CONFIG_MODULES 48 struct tp_module { 49 struct list_head list; 50 struct module *mod; 51 }; 52 53 bool trace_module_has_bad_taint(struct module *mod); 54 extern int register_tracepoint_module_notifier(struct notifier_block *nb); 55 extern int unregister_tracepoint_module_notifier(struct notifier_block *nb); 56 #else 57 static inline bool trace_module_has_bad_taint(struct module *mod) 58 { 59 return false; 60 } 61 static inline 62 int register_tracepoint_module_notifier(struct notifier_block *nb) 63 { 64 return 0; 65 } 66 static inline 67 int unregister_tracepoint_module_notifier(struct notifier_block *nb) 68 { 69 return 0; 70 } 71 #endif /* CONFIG_MODULES */ 72 73 /* 74 * tracepoint_synchronize_unregister must be called between the last tracepoint 75 * probe unregistration and the end of module exit to make sure there is no 76 * caller executing a probe when it is freed. 77 */ 78 static inline void tracepoint_synchronize_unregister(void) 79 { 80 synchronize_sched(); 81 } 82 83 #ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS 84 extern void syscall_regfunc(void); 85 extern void syscall_unregfunc(void); 86 #endif /* CONFIG_HAVE_SYSCALL_TRACEPOINTS */ 87 88 #define PARAMS(args...) args 89 90 #endif /* _LINUX_TRACEPOINT_H */ 91 92 /* 93 * Note: we keep the TRACE_EVENT and DECLARE_TRACE outside the include 94 * file ifdef protection. 95 * This is due to the way trace events work. If a file includes two 96 * trace event headers under one "CREATE_TRACE_POINTS" the first include 97 * will override the TRACE_EVENT and break the second include. 98 */ 99 100 #ifndef DECLARE_TRACE 101 102 #define TP_PROTO(args...) args 103 #define TP_ARGS(args...) args 104 #define TP_CONDITION(args...) args 105 106 #ifdef CONFIG_TRACEPOINTS 107 108 /* 109 * it_func[0] is never NULL because there is at least one element in the array 110 * when the array itself is non NULL. 111 * 112 * Note, the proto and args passed in includes "__data" as the first parameter. 113 * The reason for this is to handle the "void" prototype. If a tracepoint 114 * has a "void" prototype, then it is invalid to declare a function 115 * as "(void *, void)". The DECLARE_TRACE_NOARGS() will pass in just 116 * "void *data", where as the DECLARE_TRACE() will pass in "void *data, proto". 117 */ 118 #define __DO_TRACE(tp, proto, args, cond, prercu, postrcu) \ 119 do { \ 120 struct tracepoint_func *it_func_ptr; \ 121 void *it_func; \ 122 void *__data; \ 123 \ 124 if (!(cond)) \ 125 return; \ 126 prercu; \ 127 rcu_read_lock_sched_notrace(); \ 128 it_func_ptr = rcu_dereference_sched((tp)->funcs); \ 129 if (it_func_ptr) { \ 130 do { \ 131 it_func = (it_func_ptr)->func; \ 132 __data = (it_func_ptr)->data; \ 133 ((void(*)(proto))(it_func))(args); \ 134 } while ((++it_func_ptr)->func); \ 135 } \ 136 rcu_read_unlock_sched_notrace(); \ 137 postrcu; \ 138 } while (0) 139 140 #ifndef MODULE 141 #define __DECLARE_TRACE_RCU(name, proto, args, cond, data_proto, data_args) \ 142 static inline void trace_##name##_rcuidle(proto) \ 143 { \ 144 if (static_key_false(&__tracepoint_##name.key)) \ 145 __DO_TRACE(&__tracepoint_##name, \ 146 TP_PROTO(data_proto), \ 147 TP_ARGS(data_args), \ 148 TP_CONDITION(cond), \ 149 rcu_irq_enter(), \ 150 rcu_irq_exit()); \ 151 } 152 #else 153 #define __DECLARE_TRACE_RCU(name, proto, args, cond, data_proto, data_args) 154 #endif 155 156 /* 157 * Make sure the alignment of the structure in the __tracepoints section will 158 * not add unwanted padding between the beginning of the section and the 159 * structure. Force alignment to the same alignment as the section start. 160 */ 161 #define __DECLARE_TRACE(name, proto, args, cond, data_proto, data_args) \ 162 extern struct tracepoint __tracepoint_##name; \ 163 static inline void trace_##name(proto) \ 164 { \ 165 if (static_key_false(&__tracepoint_##name.key)) \ 166 __DO_TRACE(&__tracepoint_##name, \ 167 TP_PROTO(data_proto), \ 168 TP_ARGS(data_args), \ 169 TP_CONDITION(cond),,); \ 170 } \ 171 __DECLARE_TRACE_RCU(name, PARAMS(proto), PARAMS(args), \ 172 PARAMS(cond), PARAMS(data_proto), PARAMS(data_args)) \ 173 static inline int \ 174 register_trace_##name(void (*probe)(data_proto), void *data) \ 175 { \ 176 return tracepoint_probe_register(&__tracepoint_##name, \ 177 (void *)probe, data); \ 178 } \ 179 static inline int \ 180 unregister_trace_##name(void (*probe)(data_proto), void *data) \ 181 { \ 182 return tracepoint_probe_unregister(&__tracepoint_##name,\ 183 (void *)probe, data); \ 184 } \ 185 static inline void \ 186 check_trace_callback_type_##name(void (*cb)(data_proto)) \ 187 { \ 188 } \ 189 static inline bool \ 190 trace_##name##_enabled(void) \ 191 { \ 192 return static_key_false(&__tracepoint_##name.key); \ 193 } 194 195 /* 196 * We have no guarantee that gcc and the linker won't up-align the tracepoint 197 * structures, so we create an array of pointers that will be used for iteration 198 * on the tracepoints. 199 */ 200 #define DEFINE_TRACE_FN(name, reg, unreg) \ 201 static const char __tpstrtab_##name[] \ 202 __attribute__((section("__tracepoints_strings"))) = #name; \ 203 struct tracepoint __tracepoint_##name \ 204 __attribute__((section("__tracepoints"))) = \ 205 { __tpstrtab_##name, STATIC_KEY_INIT_FALSE, reg, unreg, NULL };\ 206 static struct tracepoint * const __tracepoint_ptr_##name __used \ 207 __attribute__((section("__tracepoints_ptrs"))) = \ 208 &__tracepoint_##name; 209 210 #define DEFINE_TRACE(name) \ 211 DEFINE_TRACE_FN(name, NULL, NULL); 212 213 #define EXPORT_TRACEPOINT_SYMBOL_GPL(name) \ 214 EXPORT_SYMBOL_GPL(__tracepoint_##name) 215 #define EXPORT_TRACEPOINT_SYMBOL(name) \ 216 EXPORT_SYMBOL(__tracepoint_##name) 217 218 #else /* !CONFIG_TRACEPOINTS */ 219 #define __DECLARE_TRACE(name, proto, args, cond, data_proto, data_args) \ 220 static inline void trace_##name(proto) \ 221 { } \ 222 static inline void trace_##name##_rcuidle(proto) \ 223 { } \ 224 static inline int \ 225 register_trace_##name(void (*probe)(data_proto), \ 226 void *data) \ 227 { \ 228 return -ENOSYS; \ 229 } \ 230 static inline int \ 231 unregister_trace_##name(void (*probe)(data_proto), \ 232 void *data) \ 233 { \ 234 return -ENOSYS; \ 235 } \ 236 static inline void check_trace_callback_type_##name(void (*cb)(data_proto)) \ 237 { \ 238 } \ 239 static inline bool \ 240 trace_##name##_enabled(void) \ 241 { \ 242 return false; \ 243 } 244 245 #define DEFINE_TRACE_FN(name, reg, unreg) 246 #define DEFINE_TRACE(name) 247 #define EXPORT_TRACEPOINT_SYMBOL_GPL(name) 248 #define EXPORT_TRACEPOINT_SYMBOL(name) 249 250 #endif /* CONFIG_TRACEPOINTS */ 251 252 #ifdef CONFIG_TRACING 253 /** 254 * tracepoint_string - register constant persistent string to trace system 255 * @str - a constant persistent string that will be referenced in tracepoints 256 * 257 * If constant strings are being used in tracepoints, it is faster and 258 * more efficient to just save the pointer to the string and reference 259 * that with a printf "%s" instead of saving the string in the ring buffer 260 * and wasting space and time. 261 * 262 * The problem with the above approach is that userspace tools that read 263 * the binary output of the trace buffers do not have access to the string. 264 * Instead they just show the address of the string which is not very 265 * useful to users. 266 * 267 * With tracepoint_string(), the string will be registered to the tracing 268 * system and exported to userspace via the debugfs/tracing/printk_formats 269 * file that maps the string address to the string text. This way userspace 270 * tools that read the binary buffers have a way to map the pointers to 271 * the ASCII strings they represent. 272 * 273 * The @str used must be a constant string and persistent as it would not 274 * make sense to show a string that no longer exists. But it is still fine 275 * to be used with modules, because when modules are unloaded, if they 276 * had tracepoints, the ring buffers are cleared too. As long as the string 277 * does not change during the life of the module, it is fine to use 278 * tracepoint_string() within a module. 279 */ 280 #define tracepoint_string(str) \ 281 ({ \ 282 static const char *___tp_str __tracepoint_string = str; \ 283 ___tp_str; \ 284 }) 285 #define __tracepoint_string __attribute__((section("__tracepoint_str"))) 286 #else 287 /* 288 * tracepoint_string() is used to save the string address for userspace 289 * tracing tools. When tracing isn't configured, there's no need to save 290 * anything. 291 */ 292 # define tracepoint_string(str) str 293 # define __tracepoint_string 294 #endif 295 296 /* 297 * The need for the DECLARE_TRACE_NOARGS() is to handle the prototype 298 * (void). "void" is a special value in a function prototype and can 299 * not be combined with other arguments. Since the DECLARE_TRACE() 300 * macro adds a data element at the beginning of the prototype, 301 * we need a way to differentiate "(void *data, proto)" from 302 * "(void *data, void)". The second prototype is invalid. 303 * 304 * DECLARE_TRACE_NOARGS() passes "void" as the tracepoint prototype 305 * and "void *__data" as the callback prototype. 306 * 307 * DECLARE_TRACE() passes "proto" as the tracepoint protoype and 308 * "void *__data, proto" as the callback prototype. 309 */ 310 #define DECLARE_TRACE_NOARGS(name) \ 311 __DECLARE_TRACE(name, void, , 1, void *__data, __data) 312 313 #define DECLARE_TRACE(name, proto, args) \ 314 __DECLARE_TRACE(name, PARAMS(proto), PARAMS(args), 1, \ 315 PARAMS(void *__data, proto), \ 316 PARAMS(__data, args)) 317 318 #define DECLARE_TRACE_CONDITION(name, proto, args, cond) \ 319 __DECLARE_TRACE(name, PARAMS(proto), PARAMS(args), PARAMS(cond), \ 320 PARAMS(void *__data, proto), \ 321 PARAMS(__data, args)) 322 323 #define TRACE_EVENT_FLAGS(event, flag) 324 325 #define TRACE_EVENT_PERF_PERM(event, expr...) 326 327 #endif /* DECLARE_TRACE */ 328 329 #ifndef TRACE_EVENT 330 /* 331 * For use with the TRACE_EVENT macro: 332 * 333 * We define a tracepoint, its arguments, its printk format 334 * and its 'fast binary record' layout. 335 * 336 * Firstly, name your tracepoint via TRACE_EVENT(name : the 337 * 'subsystem_event' notation is fine. 338 * 339 * Think about this whole construct as the 340 * 'trace_sched_switch() function' from now on. 341 * 342 * 343 * TRACE_EVENT(sched_switch, 344 * 345 * * 346 * * A function has a regular function arguments 347 * * prototype, declare it via TP_PROTO(): 348 * * 349 * 350 * TP_PROTO(struct rq *rq, struct task_struct *prev, 351 * struct task_struct *next), 352 * 353 * * 354 * * Define the call signature of the 'function'. 355 * * (Design sidenote: we use this instead of a 356 * * TP_PROTO1/TP_PROTO2/TP_PROTO3 ugliness.) 357 * * 358 * 359 * TP_ARGS(rq, prev, next), 360 * 361 * * 362 * * Fast binary tracing: define the trace record via 363 * * TP_STRUCT__entry(). You can think about it like a 364 * * regular C structure local variable definition. 365 * * 366 * * This is how the trace record is structured and will 367 * * be saved into the ring buffer. These are the fields 368 * * that will be exposed to user-space in 369 * * /sys/kernel/debug/tracing/events/<*>/format. 370 * * 371 * * The declared 'local variable' is called '__entry' 372 * * 373 * * __field(pid_t, prev_prid) is equivalent to a standard declariton: 374 * * 375 * * pid_t prev_pid; 376 * * 377 * * __array(char, prev_comm, TASK_COMM_LEN) is equivalent to: 378 * * 379 * * char prev_comm[TASK_COMM_LEN]; 380 * * 381 * 382 * TP_STRUCT__entry( 383 * __array( char, prev_comm, TASK_COMM_LEN ) 384 * __field( pid_t, prev_pid ) 385 * __field( int, prev_prio ) 386 * __array( char, next_comm, TASK_COMM_LEN ) 387 * __field( pid_t, next_pid ) 388 * __field( int, next_prio ) 389 * ), 390 * 391 * * 392 * * Assign the entry into the trace record, by embedding 393 * * a full C statement block into TP_fast_assign(). You 394 * * can refer to the trace record as '__entry' - 395 * * otherwise you can put arbitrary C code in here. 396 * * 397 * * Note: this C code will execute every time a trace event 398 * * happens, on an active tracepoint. 399 * * 400 * 401 * TP_fast_assign( 402 * memcpy(__entry->next_comm, next->comm, TASK_COMM_LEN); 403 * __entry->prev_pid = prev->pid; 404 * __entry->prev_prio = prev->prio; 405 * memcpy(__entry->prev_comm, prev->comm, TASK_COMM_LEN); 406 * __entry->next_pid = next->pid; 407 * __entry->next_prio = next->prio; 408 * ), 409 * 410 * * 411 * * Formatted output of a trace record via TP_printk(). 412 * * This is how the tracepoint will appear under ftrace 413 * * plugins that make use of this tracepoint. 414 * * 415 * * (raw-binary tracing wont actually perform this step.) 416 * * 417 * 418 * TP_printk("task %s:%d [%d] ==> %s:%d [%d]", 419 * __entry->prev_comm, __entry->prev_pid, __entry->prev_prio, 420 * __entry->next_comm, __entry->next_pid, __entry->next_prio), 421 * 422 * ); 423 * 424 * This macro construct is thus used for the regular printk format 425 * tracing setup, it is used to construct a function pointer based 426 * tracepoint callback (this is used by programmatic plugins and 427 * can also by used by generic instrumentation like SystemTap), and 428 * it is also used to expose a structured trace record in 429 * /sys/kernel/debug/tracing/events/. 430 * 431 * A set of (un)registration functions can be passed to the variant 432 * TRACE_EVENT_FN to perform any (un)registration work. 433 */ 434 435 #define DECLARE_EVENT_CLASS(name, proto, args, tstruct, assign, print) 436 #define DEFINE_EVENT(template, name, proto, args) \ 437 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args)) 438 #define DEFINE_EVENT_FN(template, name, proto, args, reg, unreg)\ 439 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args)) 440 #define DEFINE_EVENT_PRINT(template, name, proto, args, print) \ 441 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args)) 442 #define DEFINE_EVENT_CONDITION(template, name, proto, \ 443 args, cond) \ 444 DECLARE_TRACE_CONDITION(name, PARAMS(proto), \ 445 PARAMS(args), PARAMS(cond)) 446 447 #define TRACE_EVENT(name, proto, args, struct, assign, print) \ 448 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args)) 449 #define TRACE_EVENT_FN(name, proto, args, struct, \ 450 assign, print, reg, unreg) \ 451 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args)) 452 #define TRACE_EVENT_CONDITION(name, proto, args, cond, \ 453 struct, assign, print) \ 454 DECLARE_TRACE_CONDITION(name, PARAMS(proto), \ 455 PARAMS(args), PARAMS(cond)) 456 457 #define TRACE_EVENT_FLAGS(event, flag) 458 459 #define TRACE_EVENT_PERF_PERM(event, expr...) 460 461 #endif /* ifdef TRACE_EVENT (see note above) */ 462