1 /* SPDX-License-Identifier: GPL-2.0-only */ 2 #ifndef _LINUX_TRACEPOINT_H 3 #define _LINUX_TRACEPOINT_H 4 5 /* 6 * Kernel Tracepoint API. 7 * 8 * See Documentation/trace/tracepoints.rst. 9 * 10 * Copyright (C) 2008-2014 Mathieu Desnoyers <[email protected]> 11 * 12 * Heavily inspired from the Linux Kernel Markers. 13 */ 14 15 #include <linux/smp.h> 16 #include <linux/srcu.h> 17 #include <linux/errno.h> 18 #include <linux/types.h> 19 #include <linux/rcupdate.h> 20 #include <linux/rcupdate_trace.h> 21 #include <linux/tracepoint-defs.h> 22 #include <linux/static_call.h> 23 24 struct module; 25 struct tracepoint; 26 struct notifier_block; 27 28 struct trace_eval_map { 29 const char *system; 30 const char *eval_string; 31 unsigned long eval_value; 32 }; 33 34 #define TRACEPOINT_DEFAULT_PRIO 10 35 36 extern int 37 tracepoint_probe_register(struct tracepoint *tp, void *probe, void *data); 38 extern int 39 tracepoint_probe_register_prio(struct tracepoint *tp, void *probe, void *data, 40 int prio); 41 extern int 42 tracepoint_probe_register_prio_may_exist(struct tracepoint *tp, void *probe, void *data, 43 int prio); 44 extern int 45 tracepoint_probe_unregister(struct tracepoint *tp, void *probe, void *data); 46 static inline int 47 tracepoint_probe_register_may_exist(struct tracepoint *tp, void *probe, 48 void *data) 49 { 50 return tracepoint_probe_register_prio_may_exist(tp, probe, data, 51 TRACEPOINT_DEFAULT_PRIO); 52 } 53 extern void 54 for_each_kernel_tracepoint(void (*fct)(struct tracepoint *tp, void *priv), 55 void *priv); 56 57 #ifdef CONFIG_MODULES 58 struct tp_module { 59 struct list_head list; 60 struct module *mod; 61 }; 62 63 bool trace_module_has_bad_taint(struct module *mod); 64 extern int register_tracepoint_module_notifier(struct notifier_block *nb); 65 extern int unregister_tracepoint_module_notifier(struct notifier_block *nb); 66 void for_each_module_tracepoint(void (*fct)(struct tracepoint *, 67 struct module *, void *), 68 void *priv); 69 void for_each_tracepoint_in_module(struct module *, 70 void (*fct)(struct tracepoint *, 71 struct module *, void *), 72 void *priv); 73 #else 74 static inline bool trace_module_has_bad_taint(struct module *mod) 75 { 76 return false; 77 } 78 static inline 79 int register_tracepoint_module_notifier(struct notifier_block *nb) 80 { 81 return 0; 82 } 83 static inline 84 int unregister_tracepoint_module_notifier(struct notifier_block *nb) 85 { 86 return 0; 87 } 88 static inline 89 void for_each_module_tracepoint(void (*fct)(struct tracepoint *, 90 struct module *, void *), 91 void *priv) 92 { 93 } 94 static inline 95 void for_each_tracepoint_in_module(struct module *mod, 96 void (*fct)(struct tracepoint *, 97 struct module *, void *), 98 void *priv) 99 { 100 } 101 #endif /* CONFIG_MODULES */ 102 103 /* 104 * tracepoint_synchronize_unregister must be called between the last tracepoint 105 * probe unregistration and the end of module exit to make sure there is no 106 * caller executing a probe when it is freed. 107 * 108 * An alternative is to use the following for batch reclaim associated 109 * with a given tracepoint: 110 * 111 * - tracepoint_is_faultable() == false: call_rcu() 112 * - tracepoint_is_faultable() == true: call_rcu_tasks_trace() 113 */ 114 #ifdef CONFIG_TRACEPOINTS 115 static inline void tracepoint_synchronize_unregister(void) 116 { 117 synchronize_rcu_tasks_trace(); 118 synchronize_rcu(); 119 } 120 static inline bool tracepoint_is_faultable(struct tracepoint *tp) 121 { 122 return tp->ext && tp->ext->faultable; 123 } 124 #else 125 static inline void tracepoint_synchronize_unregister(void) 126 { } 127 static inline bool tracepoint_is_faultable(struct tracepoint *tp) 128 { 129 return false; 130 } 131 #endif 132 133 #ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS 134 extern int syscall_regfunc(void); 135 extern void syscall_unregfunc(void); 136 #endif /* CONFIG_HAVE_SYSCALL_TRACEPOINTS */ 137 138 #ifndef PARAMS 139 #define PARAMS(args...) args 140 #endif 141 142 #define TRACE_DEFINE_ENUM(x) 143 #define TRACE_DEFINE_SIZEOF(x) 144 145 #ifdef CONFIG_HAVE_ARCH_PREL32_RELOCATIONS 146 static inline struct tracepoint *tracepoint_ptr_deref(tracepoint_ptr_t *p) 147 { 148 return offset_to_ptr(p); 149 } 150 151 #define __TRACEPOINT_ENTRY(name) \ 152 asm(" .section \"__tracepoints_ptrs\", \"a\" \n" \ 153 " .balign 4 \n" \ 154 " .long __tracepoint_" #name " - . \n" \ 155 " .previous \n") 156 #else 157 static inline struct tracepoint *tracepoint_ptr_deref(tracepoint_ptr_t *p) 158 { 159 return *p; 160 } 161 162 #define __TRACEPOINT_ENTRY(name) \ 163 static tracepoint_ptr_t __tracepoint_ptr_##name __used \ 164 __section("__tracepoints_ptrs") = &__tracepoint_##name 165 #endif 166 167 #endif /* _LINUX_TRACEPOINT_H */ 168 169 /* 170 * Note: we keep the TRACE_EVENT and DECLARE_TRACE outside the include 171 * file ifdef protection. 172 * This is due to the way trace events work. If a file includes two 173 * trace event headers under one "CREATE_TRACE_POINTS" the first include 174 * will override the TRACE_EVENT and break the second include. 175 */ 176 177 #ifndef DECLARE_TRACE 178 179 #define TP_PROTO(args...) args 180 #define TP_ARGS(args...) args 181 #define TP_CONDITION(args...) args 182 183 /* 184 * Individual subsystem my have a separate configuration to 185 * enable their tracepoints. By default, this file will create 186 * the tracepoints if CONFIG_TRACEPOINTS is defined. If a subsystem 187 * wants to be able to disable its tracepoints from being created 188 * it can define NOTRACE before including the tracepoint headers. 189 */ 190 #if defined(CONFIG_TRACEPOINTS) && !defined(NOTRACE) 191 #define TRACEPOINTS_ENABLED 192 #endif 193 194 #ifdef TRACEPOINTS_ENABLED 195 196 #ifdef CONFIG_HAVE_STATIC_CALL 197 #define __DO_TRACE_CALL(name, args) \ 198 do { \ 199 struct tracepoint_func *it_func_ptr; \ 200 void *__data; \ 201 it_func_ptr = \ 202 rcu_dereference_raw((&__tracepoint_##name)->funcs); \ 203 if (it_func_ptr) { \ 204 __data = (it_func_ptr)->data; \ 205 static_call(tp_func_##name)(__data, args); \ 206 } \ 207 } while (0) 208 #else 209 #define __DO_TRACE_CALL(name, args) __traceiter_##name(NULL, args) 210 #endif /* CONFIG_HAVE_STATIC_CALL */ 211 212 /* 213 * it_func[0] is never NULL because there is at least one element in the array 214 * when the array itself is non NULL. 215 * 216 * With @syscall=0, the tracepoint callback array dereference is 217 * protected by disabling preemption. 218 * With @syscall=1, the tracepoint callback array dereference is 219 * protected by Tasks Trace RCU, which allows probes to handle page 220 * faults. 221 */ 222 #define __DO_TRACE(name, args, cond, syscall) \ 223 do { \ 224 int __maybe_unused __idx = 0; \ 225 \ 226 if (!(cond)) \ 227 return; \ 228 \ 229 if (syscall) \ 230 rcu_read_lock_trace(); \ 231 else \ 232 preempt_disable_notrace(); \ 233 \ 234 __DO_TRACE_CALL(name, TP_ARGS(args)); \ 235 \ 236 if (syscall) \ 237 rcu_read_unlock_trace(); \ 238 else \ 239 preempt_enable_notrace(); \ 240 } while (0) 241 242 /* 243 * Declare an exported function that Rust code can call to trigger this 244 * tracepoint. This function does not include the static branch; that is done 245 * in Rust to avoid a function call when the tracepoint is disabled. 246 */ 247 #define DEFINE_RUST_DO_TRACE(name, proto, args) 248 #define __DEFINE_RUST_DO_TRACE(name, proto, args) \ 249 notrace void rust_do_trace_##name(proto) \ 250 { \ 251 __rust_do_trace_##name(args); \ 252 } 253 254 /* 255 * Make sure the alignment of the structure in the __tracepoints section will 256 * not add unwanted padding between the beginning of the section and the 257 * structure. Force alignment to the same alignment as the section start. 258 * 259 * When lockdep is enabled, we make sure to always test if RCU is 260 * "watching" regardless if the tracepoint is enabled or not. Tracepoints 261 * require RCU to be active, and it should always warn at the tracepoint 262 * site if it is not watching, as it will need to be active when the 263 * tracepoint is enabled. 264 */ 265 #define __DECLARE_TRACE_COMMON(name, proto, args, cond, data_proto) \ 266 extern int __traceiter_##name(data_proto); \ 267 DECLARE_STATIC_CALL(tp_func_##name, __traceiter_##name); \ 268 extern struct tracepoint __tracepoint_##name; \ 269 extern void rust_do_trace_##name(proto); \ 270 static inline int \ 271 register_trace_##name(void (*probe)(data_proto), void *data) \ 272 { \ 273 return tracepoint_probe_register(&__tracepoint_##name, \ 274 (void *)probe, data); \ 275 } \ 276 static inline int \ 277 register_trace_prio_##name(void (*probe)(data_proto), void *data,\ 278 int prio) \ 279 { \ 280 return tracepoint_probe_register_prio(&__tracepoint_##name, \ 281 (void *)probe, data, prio); \ 282 } \ 283 static inline int \ 284 unregister_trace_##name(void (*probe)(data_proto), void *data) \ 285 { \ 286 return tracepoint_probe_unregister(&__tracepoint_##name,\ 287 (void *)probe, data); \ 288 } \ 289 static inline void \ 290 check_trace_callback_type_##name(void (*cb)(data_proto)) \ 291 { \ 292 } \ 293 static inline bool \ 294 trace_##name##_enabled(void) \ 295 { \ 296 return static_branch_unlikely(&__tracepoint_##name.key);\ 297 } 298 299 #define __DECLARE_TRACE(name, proto, args, cond, data_proto) \ 300 __DECLARE_TRACE_COMMON(name, PARAMS(proto), PARAMS(args), cond, PARAMS(data_proto)) \ 301 static inline void __rust_do_trace_##name(proto) \ 302 { \ 303 __DO_TRACE(name, \ 304 TP_ARGS(args), \ 305 TP_CONDITION(cond), 0); \ 306 } \ 307 static inline void trace_##name(proto) \ 308 { \ 309 if (static_branch_unlikely(&__tracepoint_##name.key)) \ 310 __DO_TRACE(name, \ 311 TP_ARGS(args), \ 312 TP_CONDITION(cond), 0); \ 313 if (IS_ENABLED(CONFIG_LOCKDEP) && (cond)) { \ 314 WARN_ONCE(!rcu_is_watching(), \ 315 "RCU not watching for tracepoint"); \ 316 } \ 317 } 318 319 #define __DECLARE_TRACE_SYSCALL(name, proto, args, cond, data_proto) \ 320 __DECLARE_TRACE_COMMON(name, PARAMS(proto), PARAMS(args), cond, PARAMS(data_proto)) \ 321 static inline void __rust_do_trace_##name(proto) \ 322 { \ 323 __DO_TRACE(name, \ 324 TP_ARGS(args), \ 325 TP_CONDITION(cond), 1); \ 326 } \ 327 static inline void trace_##name(proto) \ 328 { \ 329 might_fault(); \ 330 if (static_branch_unlikely(&__tracepoint_##name.key)) \ 331 __DO_TRACE(name, \ 332 TP_ARGS(args), \ 333 TP_CONDITION(cond), 1); \ 334 if (IS_ENABLED(CONFIG_LOCKDEP) && (cond)) { \ 335 WARN_ONCE(!rcu_is_watching(), \ 336 "RCU not watching for tracepoint"); \ 337 } \ 338 } 339 340 /* 341 * We have no guarantee that gcc and the linker won't up-align the tracepoint 342 * structures, so we create an array of pointers that will be used for iteration 343 * on the tracepoints. 344 */ 345 #define __DEFINE_TRACE_EXT(_name, _ext, proto, args) \ 346 static const char __tpstrtab_##_name[] \ 347 __section("__tracepoints_strings") = #_name; \ 348 extern struct static_call_key STATIC_CALL_KEY(tp_func_##_name); \ 349 int __traceiter_##_name(void *__data, proto); \ 350 void __probestub_##_name(void *__data, proto); \ 351 struct tracepoint __tracepoint_##_name __used \ 352 __section("__tracepoints") = { \ 353 .name = __tpstrtab_##_name, \ 354 .key = STATIC_KEY_FALSE_INIT, \ 355 .static_call_key = &STATIC_CALL_KEY(tp_func_##_name), \ 356 .static_call_tramp = STATIC_CALL_TRAMP_ADDR(tp_func_##_name), \ 357 .iterator = &__traceiter_##_name, \ 358 .probestub = &__probestub_##_name, \ 359 .funcs = NULL, \ 360 .ext = _ext, \ 361 }; \ 362 __TRACEPOINT_ENTRY(_name); \ 363 int __traceiter_##_name(void *__data, proto) \ 364 { \ 365 struct tracepoint_func *it_func_ptr; \ 366 void *it_func; \ 367 \ 368 it_func_ptr = \ 369 rcu_dereference_raw((&__tracepoint_##_name)->funcs); \ 370 if (it_func_ptr) { \ 371 do { \ 372 it_func = READ_ONCE((it_func_ptr)->func); \ 373 __data = (it_func_ptr)->data; \ 374 ((void(*)(void *, proto))(it_func))(__data, args); \ 375 } while ((++it_func_ptr)->func); \ 376 } \ 377 return 0; \ 378 } \ 379 void __probestub_##_name(void *__data, proto) \ 380 { \ 381 } \ 382 DEFINE_STATIC_CALL(tp_func_##_name, __traceiter_##_name); \ 383 DEFINE_RUST_DO_TRACE(_name, TP_PROTO(proto), TP_ARGS(args)) 384 385 #define DEFINE_TRACE_FN(_name, _reg, _unreg, _proto, _args) \ 386 static struct tracepoint_ext __tracepoint_ext_##_name = { \ 387 .regfunc = _reg, \ 388 .unregfunc = _unreg, \ 389 .faultable = false, \ 390 }; \ 391 __DEFINE_TRACE_EXT(_name, &__tracepoint_ext_##_name, PARAMS(_proto), PARAMS(_args)); 392 393 #define DEFINE_TRACE_SYSCALL(_name, _reg, _unreg, _proto, _args) \ 394 static struct tracepoint_ext __tracepoint_ext_##_name = { \ 395 .regfunc = _reg, \ 396 .unregfunc = _unreg, \ 397 .faultable = true, \ 398 }; \ 399 __DEFINE_TRACE_EXT(_name, &__tracepoint_ext_##_name, PARAMS(_proto), PARAMS(_args)); 400 401 #define DEFINE_TRACE(_name, _proto, _args) \ 402 __DEFINE_TRACE_EXT(_name, NULL, PARAMS(_proto), PARAMS(_args)); 403 404 #define EXPORT_TRACEPOINT_SYMBOL_GPL(name) \ 405 EXPORT_SYMBOL_GPL(__tracepoint_##name); \ 406 EXPORT_SYMBOL_GPL(__traceiter_##name); \ 407 EXPORT_STATIC_CALL_GPL(tp_func_##name) 408 #define EXPORT_TRACEPOINT_SYMBOL(name) \ 409 EXPORT_SYMBOL(__tracepoint_##name); \ 410 EXPORT_SYMBOL(__traceiter_##name); \ 411 EXPORT_STATIC_CALL(tp_func_##name) 412 413 414 #else /* !TRACEPOINTS_ENABLED */ 415 #define __DECLARE_TRACE(name, proto, args, cond, data_proto) \ 416 static inline void trace_##name(proto) \ 417 { } \ 418 static inline int \ 419 register_trace_##name(void (*probe)(data_proto), \ 420 void *data) \ 421 { \ 422 return -ENOSYS; \ 423 } \ 424 static inline int \ 425 unregister_trace_##name(void (*probe)(data_proto), \ 426 void *data) \ 427 { \ 428 return -ENOSYS; \ 429 } \ 430 static inline void check_trace_callback_type_##name(void (*cb)(data_proto)) \ 431 { \ 432 } \ 433 static inline bool \ 434 trace_##name##_enabled(void) \ 435 { \ 436 return false; \ 437 } 438 439 #define __DECLARE_TRACE_SYSCALL __DECLARE_TRACE 440 441 #define DEFINE_TRACE_FN(name, reg, unreg, proto, args) 442 #define DEFINE_TRACE_SYSCALL(name, reg, unreg, proto, args) 443 #define DEFINE_TRACE(name, proto, args) 444 #define EXPORT_TRACEPOINT_SYMBOL_GPL(name) 445 #define EXPORT_TRACEPOINT_SYMBOL(name) 446 447 #endif /* TRACEPOINTS_ENABLED */ 448 449 #ifdef CONFIG_TRACING 450 /** 451 * tracepoint_string - register constant persistent string to trace system 452 * @str - a constant persistent string that will be referenced in tracepoints 453 * 454 * If constant strings are being used in tracepoints, it is faster and 455 * more efficient to just save the pointer to the string and reference 456 * that with a printf "%s" instead of saving the string in the ring buffer 457 * and wasting space and time. 458 * 459 * The problem with the above approach is that userspace tools that read 460 * the binary output of the trace buffers do not have access to the string. 461 * Instead they just show the address of the string which is not very 462 * useful to users. 463 * 464 * With tracepoint_string(), the string will be registered to the tracing 465 * system and exported to userspace via the debugfs/tracing/printk_formats 466 * file that maps the string address to the string text. This way userspace 467 * tools that read the binary buffers have a way to map the pointers to 468 * the ASCII strings they represent. 469 * 470 * The @str used must be a constant string and persistent as it would not 471 * make sense to show a string that no longer exists. But it is still fine 472 * to be used with modules, because when modules are unloaded, if they 473 * had tracepoints, the ring buffers are cleared too. As long as the string 474 * does not change during the life of the module, it is fine to use 475 * tracepoint_string() within a module. 476 */ 477 #define tracepoint_string(str) \ 478 ({ \ 479 static const char *___tp_str __tracepoint_string = str; \ 480 ___tp_str; \ 481 }) 482 #define __tracepoint_string __used __section("__tracepoint_str") 483 #else 484 /* 485 * tracepoint_string() is used to save the string address for userspace 486 * tracing tools. When tracing isn't configured, there's no need to save 487 * anything. 488 */ 489 # define tracepoint_string(str) str 490 # define __tracepoint_string 491 #endif 492 493 #define DECLARE_TRACE(name, proto, args) \ 494 __DECLARE_TRACE(name, PARAMS(proto), PARAMS(args), \ 495 cpu_online(raw_smp_processor_id()), \ 496 PARAMS(void *__data, proto)) 497 498 #define DECLARE_TRACE_CONDITION(name, proto, args, cond) \ 499 __DECLARE_TRACE(name, PARAMS(proto), PARAMS(args), \ 500 cpu_online(raw_smp_processor_id()) && (PARAMS(cond)), \ 501 PARAMS(void *__data, proto)) 502 503 #define DECLARE_TRACE_SYSCALL(name, proto, args) \ 504 __DECLARE_TRACE_SYSCALL(name, PARAMS(proto), PARAMS(args), \ 505 cpu_online(raw_smp_processor_id()), \ 506 PARAMS(void *__data, proto)) 507 508 #define TRACE_EVENT_FLAGS(event, flag) 509 510 #define TRACE_EVENT_PERF_PERM(event, expr...) 511 512 #endif /* DECLARE_TRACE */ 513 514 #ifndef TRACE_EVENT 515 /* 516 * For use with the TRACE_EVENT macro: 517 * 518 * We define a tracepoint, its arguments, its printk format 519 * and its 'fast binary record' layout. 520 * 521 * Firstly, name your tracepoint via TRACE_EVENT(name : the 522 * 'subsystem_event' notation is fine. 523 * 524 * Think about this whole construct as the 525 * 'trace_sched_switch() function' from now on. 526 * 527 * 528 * TRACE_EVENT(sched_switch, 529 * 530 * * 531 * * A function has a regular function arguments 532 * * prototype, declare it via TP_PROTO(): 533 * * 534 * 535 * TP_PROTO(struct rq *rq, struct task_struct *prev, 536 * struct task_struct *next), 537 * 538 * * 539 * * Define the call signature of the 'function'. 540 * * (Design sidenote: we use this instead of a 541 * * TP_PROTO1/TP_PROTO2/TP_PROTO3 ugliness.) 542 * * 543 * 544 * TP_ARGS(rq, prev, next), 545 * 546 * * 547 * * Fast binary tracing: define the trace record via 548 * * TP_STRUCT__entry(). You can think about it like a 549 * * regular C structure local variable definition. 550 * * 551 * * This is how the trace record is structured and will 552 * * be saved into the ring buffer. These are the fields 553 * * that will be exposed to user-space in 554 * * /sys/kernel/tracing/events/<*>/format. 555 * * 556 * * The declared 'local variable' is called '__entry' 557 * * 558 * * __field(pid_t, prev_pid) is equivalent to a standard declaration: 559 * * 560 * * pid_t prev_pid; 561 * * 562 * * __array(char, prev_comm, TASK_COMM_LEN) is equivalent to: 563 * * 564 * * char prev_comm[TASK_COMM_LEN]; 565 * * 566 * 567 * TP_STRUCT__entry( 568 * __array( char, prev_comm, TASK_COMM_LEN ) 569 * __field( pid_t, prev_pid ) 570 * __field( int, prev_prio ) 571 * __array( char, next_comm, TASK_COMM_LEN ) 572 * __field( pid_t, next_pid ) 573 * __field( int, next_prio ) 574 * ), 575 * 576 * * 577 * * Assign the entry into the trace record, by embedding 578 * * a full C statement block into TP_fast_assign(). You 579 * * can refer to the trace record as '__entry' - 580 * * otherwise you can put arbitrary C code in here. 581 * * 582 * * Note: this C code will execute every time a trace event 583 * * happens, on an active tracepoint. 584 * * 585 * 586 * TP_fast_assign( 587 * memcpy(__entry->next_comm, next->comm, TASK_COMM_LEN); 588 * __entry->prev_pid = prev->pid; 589 * __entry->prev_prio = prev->prio; 590 * memcpy(__entry->prev_comm, prev->comm, TASK_COMM_LEN); 591 * __entry->next_pid = next->pid; 592 * __entry->next_prio = next->prio; 593 * ), 594 * 595 * * 596 * * Formatted output of a trace record via TP_printk(). 597 * * This is how the tracepoint will appear under ftrace 598 * * plugins that make use of this tracepoint. 599 * * 600 * * (raw-binary tracing wont actually perform this step.) 601 * * 602 * 603 * TP_printk("task %s:%d [%d] ==> %s:%d [%d]", 604 * __entry->prev_comm, __entry->prev_pid, __entry->prev_prio, 605 * __entry->next_comm, __entry->next_pid, __entry->next_prio), 606 * 607 * ); 608 * 609 * This macro construct is thus used for the regular printk format 610 * tracing setup, it is used to construct a function pointer based 611 * tracepoint callback (this is used by programmatic plugins and 612 * can also by used by generic instrumentation like SystemTap), and 613 * it is also used to expose a structured trace record in 614 * /sys/kernel/tracing/events/. 615 * 616 * A set of (un)registration functions can be passed to the variant 617 * TRACE_EVENT_FN to perform any (un)registration work. 618 */ 619 620 #define DECLARE_EVENT_CLASS(name, proto, args, tstruct, assign, print) 621 #define DEFINE_EVENT(template, name, proto, args) \ 622 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args)) 623 #define DEFINE_EVENT_FN(template, name, proto, args, reg, unreg)\ 624 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args)) 625 #define DEFINE_EVENT_PRINT(template, name, proto, args, print) \ 626 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args)) 627 #define DEFINE_EVENT_CONDITION(template, name, proto, \ 628 args, cond) \ 629 DECLARE_TRACE_CONDITION(name, PARAMS(proto), \ 630 PARAMS(args), PARAMS(cond)) 631 632 #define TRACE_EVENT(name, proto, args, struct, assign, print) \ 633 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args)) 634 #define TRACE_EVENT_FN(name, proto, args, struct, \ 635 assign, print, reg, unreg) \ 636 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args)) 637 #define TRACE_EVENT_FN_COND(name, proto, args, cond, struct, \ 638 assign, print, reg, unreg) \ 639 DECLARE_TRACE_CONDITION(name, PARAMS(proto), \ 640 PARAMS(args), PARAMS(cond)) 641 #define TRACE_EVENT_CONDITION(name, proto, args, cond, \ 642 struct, assign, print) \ 643 DECLARE_TRACE_CONDITION(name, PARAMS(proto), \ 644 PARAMS(args), PARAMS(cond)) 645 #define TRACE_EVENT_SYSCALL(name, proto, args, struct, assign, \ 646 print, reg, unreg) \ 647 DECLARE_TRACE_SYSCALL(name, PARAMS(proto), PARAMS(args)) 648 649 #define TRACE_EVENT_FLAGS(event, flag) 650 651 #define TRACE_EVENT_PERF_PERM(event, expr...) 652 653 #define DECLARE_EVENT_NOP(name, proto, args) \ 654 static inline void trace_##name(proto) \ 655 { } \ 656 static inline bool trace_##name##_enabled(void) \ 657 { \ 658 return false; \ 659 } 660 661 #define TRACE_EVENT_NOP(name, proto, args, struct, assign, print) \ 662 DECLARE_EVENT_NOP(name, PARAMS(proto), PARAMS(args)) 663 664 #define DECLARE_EVENT_CLASS_NOP(name, proto, args, tstruct, assign, print) 665 #define DEFINE_EVENT_NOP(template, name, proto, args) \ 666 DECLARE_EVENT_NOP(name, PARAMS(proto), PARAMS(args)) 667 668 #endif /* ifdef TRACE_EVENT (see note above) */ 669