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 * Make sure the alignment of the structure in the __tracepoints section will 244 * not add unwanted padding between the beginning of the section and the 245 * structure. Force alignment to the same alignment as the section start. 246 * 247 * When lockdep is enabled, we make sure to always test if RCU is 248 * "watching" regardless if the tracepoint is enabled or not. Tracepoints 249 * require RCU to be active, and it should always warn at the tracepoint 250 * site if it is not watching, as it will need to be active when the 251 * tracepoint is enabled. 252 */ 253 #define __DECLARE_TRACE_COMMON(name, proto, args, cond, data_proto) \ 254 extern int __traceiter_##name(data_proto); \ 255 DECLARE_STATIC_CALL(tp_func_##name, __traceiter_##name); \ 256 extern struct tracepoint __tracepoint_##name; \ 257 static inline int \ 258 register_trace_##name(void (*probe)(data_proto), void *data) \ 259 { \ 260 return tracepoint_probe_register(&__tracepoint_##name, \ 261 (void *)probe, data); \ 262 } \ 263 static inline int \ 264 register_trace_prio_##name(void (*probe)(data_proto), void *data,\ 265 int prio) \ 266 { \ 267 return tracepoint_probe_register_prio(&__tracepoint_##name, \ 268 (void *)probe, data, prio); \ 269 } \ 270 static inline int \ 271 unregister_trace_##name(void (*probe)(data_proto), void *data) \ 272 { \ 273 return tracepoint_probe_unregister(&__tracepoint_##name,\ 274 (void *)probe, data); \ 275 } \ 276 static inline void \ 277 check_trace_callback_type_##name(void (*cb)(data_proto)) \ 278 { \ 279 } \ 280 static inline bool \ 281 trace_##name##_enabled(void) \ 282 { \ 283 return static_branch_unlikely(&__tracepoint_##name.key);\ 284 } 285 286 #define __DECLARE_TRACE(name, proto, args, cond, data_proto) \ 287 __DECLARE_TRACE_COMMON(name, PARAMS(proto), PARAMS(args), cond, PARAMS(data_proto)) \ 288 static inline void trace_##name(proto) \ 289 { \ 290 if (static_branch_unlikely(&__tracepoint_##name.key)) \ 291 __DO_TRACE(name, \ 292 TP_ARGS(args), \ 293 TP_CONDITION(cond), 0); \ 294 if (IS_ENABLED(CONFIG_LOCKDEP) && (cond)) { \ 295 WARN_ONCE(!rcu_is_watching(), \ 296 "RCU not watching for tracepoint"); \ 297 } \ 298 } 299 300 #define __DECLARE_TRACE_SYSCALL(name, proto, args, cond, data_proto) \ 301 __DECLARE_TRACE_COMMON(name, PARAMS(proto), PARAMS(args), cond, PARAMS(data_proto)) \ 302 static inline void trace_##name(proto) \ 303 { \ 304 might_fault(); \ 305 if (static_branch_unlikely(&__tracepoint_##name.key)) \ 306 __DO_TRACE(name, \ 307 TP_ARGS(args), \ 308 TP_CONDITION(cond), 1); \ 309 if (IS_ENABLED(CONFIG_LOCKDEP) && (cond)) { \ 310 WARN_ONCE(!rcu_is_watching(), \ 311 "RCU not watching for tracepoint"); \ 312 } \ 313 } 314 315 /* 316 * We have no guarantee that gcc and the linker won't up-align the tracepoint 317 * structures, so we create an array of pointers that will be used for iteration 318 * on the tracepoints. 319 */ 320 #define __DEFINE_TRACE_EXT(_name, _ext, proto, args) \ 321 static const char __tpstrtab_##_name[] \ 322 __section("__tracepoints_strings") = #_name; \ 323 extern struct static_call_key STATIC_CALL_KEY(tp_func_##_name); \ 324 int __traceiter_##_name(void *__data, proto); \ 325 void __probestub_##_name(void *__data, proto); \ 326 struct tracepoint __tracepoint_##_name __used \ 327 __section("__tracepoints") = { \ 328 .name = __tpstrtab_##_name, \ 329 .key = STATIC_KEY_FALSE_INIT, \ 330 .static_call_key = &STATIC_CALL_KEY(tp_func_##_name), \ 331 .static_call_tramp = STATIC_CALL_TRAMP_ADDR(tp_func_##_name), \ 332 .iterator = &__traceiter_##_name, \ 333 .probestub = &__probestub_##_name, \ 334 .funcs = NULL, \ 335 .ext = _ext, \ 336 }; \ 337 __TRACEPOINT_ENTRY(_name); \ 338 int __traceiter_##_name(void *__data, proto) \ 339 { \ 340 struct tracepoint_func *it_func_ptr; \ 341 void *it_func; \ 342 \ 343 it_func_ptr = \ 344 rcu_dereference_raw((&__tracepoint_##_name)->funcs); \ 345 if (it_func_ptr) { \ 346 do { \ 347 it_func = READ_ONCE((it_func_ptr)->func); \ 348 __data = (it_func_ptr)->data; \ 349 ((void(*)(void *, proto))(it_func))(__data, args); \ 350 } while ((++it_func_ptr)->func); \ 351 } \ 352 return 0; \ 353 } \ 354 void __probestub_##_name(void *__data, proto) \ 355 { \ 356 } \ 357 DEFINE_STATIC_CALL(tp_func_##_name, __traceiter_##_name); 358 359 #define DEFINE_TRACE_FN(_name, _reg, _unreg, _proto, _args) \ 360 static struct tracepoint_ext __tracepoint_ext_##_name = { \ 361 .regfunc = _reg, \ 362 .unregfunc = _unreg, \ 363 .faultable = false, \ 364 }; \ 365 __DEFINE_TRACE_EXT(_name, &__tracepoint_ext_##_name, PARAMS(_proto), PARAMS(_args)); 366 367 #define DEFINE_TRACE_SYSCALL(_name, _reg, _unreg, _proto, _args) \ 368 static struct tracepoint_ext __tracepoint_ext_##_name = { \ 369 .regfunc = _reg, \ 370 .unregfunc = _unreg, \ 371 .faultable = true, \ 372 }; \ 373 __DEFINE_TRACE_EXT(_name, &__tracepoint_ext_##_name, PARAMS(_proto), PARAMS(_args)); 374 375 #define DEFINE_TRACE(_name, _proto, _args) \ 376 __DEFINE_TRACE_EXT(_name, NULL, PARAMS(_proto), PARAMS(_args)); 377 378 #define EXPORT_TRACEPOINT_SYMBOL_GPL(name) \ 379 EXPORT_SYMBOL_GPL(__tracepoint_##name); \ 380 EXPORT_SYMBOL_GPL(__traceiter_##name); \ 381 EXPORT_STATIC_CALL_GPL(tp_func_##name) 382 #define EXPORT_TRACEPOINT_SYMBOL(name) \ 383 EXPORT_SYMBOL(__tracepoint_##name); \ 384 EXPORT_SYMBOL(__traceiter_##name); \ 385 EXPORT_STATIC_CALL(tp_func_##name) 386 387 388 #else /* !TRACEPOINTS_ENABLED */ 389 #define __DECLARE_TRACE(name, proto, args, cond, data_proto) \ 390 static inline void trace_##name(proto) \ 391 { } \ 392 static inline int \ 393 register_trace_##name(void (*probe)(data_proto), \ 394 void *data) \ 395 { \ 396 return -ENOSYS; \ 397 } \ 398 static inline int \ 399 unregister_trace_##name(void (*probe)(data_proto), \ 400 void *data) \ 401 { \ 402 return -ENOSYS; \ 403 } \ 404 static inline void check_trace_callback_type_##name(void (*cb)(data_proto)) \ 405 { \ 406 } \ 407 static inline bool \ 408 trace_##name##_enabled(void) \ 409 { \ 410 return false; \ 411 } 412 413 #define __DECLARE_TRACE_SYSCALL __DECLARE_TRACE 414 415 #define DEFINE_TRACE_FN(name, reg, unreg, proto, args) 416 #define DEFINE_TRACE_SYSCALL(name, reg, unreg, proto, args) 417 #define DEFINE_TRACE(name, proto, args) 418 #define EXPORT_TRACEPOINT_SYMBOL_GPL(name) 419 #define EXPORT_TRACEPOINT_SYMBOL(name) 420 421 #endif /* TRACEPOINTS_ENABLED */ 422 423 #ifdef CONFIG_TRACING 424 /** 425 * tracepoint_string - register constant persistent string to trace system 426 * @str - a constant persistent string that will be referenced in tracepoints 427 * 428 * If constant strings are being used in tracepoints, it is faster and 429 * more efficient to just save the pointer to the string and reference 430 * that with a printf "%s" instead of saving the string in the ring buffer 431 * and wasting space and time. 432 * 433 * The problem with the above approach is that userspace tools that read 434 * the binary output of the trace buffers do not have access to the string. 435 * Instead they just show the address of the string which is not very 436 * useful to users. 437 * 438 * With tracepoint_string(), the string will be registered to the tracing 439 * system and exported to userspace via the debugfs/tracing/printk_formats 440 * file that maps the string address to the string text. This way userspace 441 * tools that read the binary buffers have a way to map the pointers to 442 * the ASCII strings they represent. 443 * 444 * The @str used must be a constant string and persistent as it would not 445 * make sense to show a string that no longer exists. But it is still fine 446 * to be used with modules, because when modules are unloaded, if they 447 * had tracepoints, the ring buffers are cleared too. As long as the string 448 * does not change during the life of the module, it is fine to use 449 * tracepoint_string() within a module. 450 */ 451 #define tracepoint_string(str) \ 452 ({ \ 453 static const char *___tp_str __tracepoint_string = str; \ 454 ___tp_str; \ 455 }) 456 #define __tracepoint_string __used __section("__tracepoint_str") 457 #else 458 /* 459 * tracepoint_string() is used to save the string address for userspace 460 * tracing tools. When tracing isn't configured, there's no need to save 461 * anything. 462 */ 463 # define tracepoint_string(str) str 464 # define __tracepoint_string 465 #endif 466 467 #define DECLARE_TRACE(name, proto, args) \ 468 __DECLARE_TRACE(name, PARAMS(proto), PARAMS(args), \ 469 cpu_online(raw_smp_processor_id()), \ 470 PARAMS(void *__data, proto)) 471 472 #define DECLARE_TRACE_CONDITION(name, proto, args, cond) \ 473 __DECLARE_TRACE(name, PARAMS(proto), PARAMS(args), \ 474 cpu_online(raw_smp_processor_id()) && (PARAMS(cond)), \ 475 PARAMS(void *__data, proto)) 476 477 #define DECLARE_TRACE_SYSCALL(name, proto, args) \ 478 __DECLARE_TRACE_SYSCALL(name, PARAMS(proto), PARAMS(args), \ 479 cpu_online(raw_smp_processor_id()), \ 480 PARAMS(void *__data, proto)) 481 482 #define TRACE_EVENT_FLAGS(event, flag) 483 484 #define TRACE_EVENT_PERF_PERM(event, expr...) 485 486 #endif /* DECLARE_TRACE */ 487 488 #ifndef TRACE_EVENT 489 /* 490 * For use with the TRACE_EVENT macro: 491 * 492 * We define a tracepoint, its arguments, its printk format 493 * and its 'fast binary record' layout. 494 * 495 * Firstly, name your tracepoint via TRACE_EVENT(name : the 496 * 'subsystem_event' notation is fine. 497 * 498 * Think about this whole construct as the 499 * 'trace_sched_switch() function' from now on. 500 * 501 * 502 * TRACE_EVENT(sched_switch, 503 * 504 * * 505 * * A function has a regular function arguments 506 * * prototype, declare it via TP_PROTO(): 507 * * 508 * 509 * TP_PROTO(struct rq *rq, struct task_struct *prev, 510 * struct task_struct *next), 511 * 512 * * 513 * * Define the call signature of the 'function'. 514 * * (Design sidenote: we use this instead of a 515 * * TP_PROTO1/TP_PROTO2/TP_PROTO3 ugliness.) 516 * * 517 * 518 * TP_ARGS(rq, prev, next), 519 * 520 * * 521 * * Fast binary tracing: define the trace record via 522 * * TP_STRUCT__entry(). You can think about it like a 523 * * regular C structure local variable definition. 524 * * 525 * * This is how the trace record is structured and will 526 * * be saved into the ring buffer. These are the fields 527 * * that will be exposed to user-space in 528 * * /sys/kernel/tracing/events/<*>/format. 529 * * 530 * * The declared 'local variable' is called '__entry' 531 * * 532 * * __field(pid_t, prev_pid) is equivalent to a standard declaration: 533 * * 534 * * pid_t prev_pid; 535 * * 536 * * __array(char, prev_comm, TASK_COMM_LEN) is equivalent to: 537 * * 538 * * char prev_comm[TASK_COMM_LEN]; 539 * * 540 * 541 * TP_STRUCT__entry( 542 * __array( char, prev_comm, TASK_COMM_LEN ) 543 * __field( pid_t, prev_pid ) 544 * __field( int, prev_prio ) 545 * __array( char, next_comm, TASK_COMM_LEN ) 546 * __field( pid_t, next_pid ) 547 * __field( int, next_prio ) 548 * ), 549 * 550 * * 551 * * Assign the entry into the trace record, by embedding 552 * * a full C statement block into TP_fast_assign(). You 553 * * can refer to the trace record as '__entry' - 554 * * otherwise you can put arbitrary C code in here. 555 * * 556 * * Note: this C code will execute every time a trace event 557 * * happens, on an active tracepoint. 558 * * 559 * 560 * TP_fast_assign( 561 * memcpy(__entry->next_comm, next->comm, TASK_COMM_LEN); 562 * __entry->prev_pid = prev->pid; 563 * __entry->prev_prio = prev->prio; 564 * memcpy(__entry->prev_comm, prev->comm, TASK_COMM_LEN); 565 * __entry->next_pid = next->pid; 566 * __entry->next_prio = next->prio; 567 * ), 568 * 569 * * 570 * * Formatted output of a trace record via TP_printk(). 571 * * This is how the tracepoint will appear under ftrace 572 * * plugins that make use of this tracepoint. 573 * * 574 * * (raw-binary tracing wont actually perform this step.) 575 * * 576 * 577 * TP_printk("task %s:%d [%d] ==> %s:%d [%d]", 578 * __entry->prev_comm, __entry->prev_pid, __entry->prev_prio, 579 * __entry->next_comm, __entry->next_pid, __entry->next_prio), 580 * 581 * ); 582 * 583 * This macro construct is thus used for the regular printk format 584 * tracing setup, it is used to construct a function pointer based 585 * tracepoint callback (this is used by programmatic plugins and 586 * can also by used by generic instrumentation like SystemTap), and 587 * it is also used to expose a structured trace record in 588 * /sys/kernel/tracing/events/. 589 * 590 * A set of (un)registration functions can be passed to the variant 591 * TRACE_EVENT_FN to perform any (un)registration work. 592 */ 593 594 #define DECLARE_EVENT_CLASS(name, proto, args, tstruct, assign, print) 595 #define DEFINE_EVENT(template, name, proto, args) \ 596 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args)) 597 #define DEFINE_EVENT_FN(template, name, proto, args, reg, unreg)\ 598 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args)) 599 #define DEFINE_EVENT_PRINT(template, name, proto, args, print) \ 600 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args)) 601 #define DEFINE_EVENT_CONDITION(template, name, proto, \ 602 args, cond) \ 603 DECLARE_TRACE_CONDITION(name, PARAMS(proto), \ 604 PARAMS(args), PARAMS(cond)) 605 606 #define TRACE_EVENT(name, proto, args, struct, assign, print) \ 607 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args)) 608 #define TRACE_EVENT_FN(name, proto, args, struct, \ 609 assign, print, reg, unreg) \ 610 DECLARE_TRACE(name, PARAMS(proto), PARAMS(args)) 611 #define TRACE_EVENT_FN_COND(name, proto, args, cond, struct, \ 612 assign, print, reg, unreg) \ 613 DECLARE_TRACE_CONDITION(name, PARAMS(proto), \ 614 PARAMS(args), PARAMS(cond)) 615 #define TRACE_EVENT_CONDITION(name, proto, args, cond, \ 616 struct, assign, print) \ 617 DECLARE_TRACE_CONDITION(name, PARAMS(proto), \ 618 PARAMS(args), PARAMS(cond)) 619 #define TRACE_EVENT_SYSCALL(name, proto, args, struct, assign, \ 620 print, reg, unreg) \ 621 DECLARE_TRACE_SYSCALL(name, PARAMS(proto), PARAMS(args)) 622 623 #define TRACE_EVENT_FLAGS(event, flag) 624 625 #define TRACE_EVENT_PERF_PERM(event, expr...) 626 627 #define DECLARE_EVENT_NOP(name, proto, args) \ 628 static inline void trace_##name(proto) \ 629 { } \ 630 static inline bool trace_##name##_enabled(void) \ 631 { \ 632 return false; \ 633 } 634 635 #define TRACE_EVENT_NOP(name, proto, args, struct, assign, print) \ 636 DECLARE_EVENT_NOP(name, PARAMS(proto), PARAMS(args)) 637 638 #define DECLARE_EVENT_CLASS_NOP(name, proto, args, tstruct, assign, print) 639 #define DEFINE_EVENT_NOP(template, name, proto, args) \ 640 DECLARE_EVENT_NOP(name, PARAMS(proto), PARAMS(args)) 641 642 #endif /* ifdef TRACE_EVENT (see note above) */ 643