kernel/trace/trace.h

   1
   2 #ifndef _LINUX_KERNEL_TRACE_H
   3 #define _LINUX_KERNEL_TRACE_H
   4
   5 #include <linux/fs.h>
   6 #include <linux/atomic.h>
   7 #include <linux/sched.h>
   8 #include <linux/clocksource.h>
   9 #include <linux/ring_buffer.h>
  10 #include <linux/mmiotrace.h>
  11 #include <linux/tracepoint.h>
  12 #include <linux/ftrace.h>
  13 #include <linux/hw_breakpoint.h>
  14 #include <linux/trace_seq.h>
  15 #include <linux/trace_events.h>
  16 #include <linux/compiler.h>
  17 #include <linux/trace_seq.h>
  18
  19 #ifdef CONFIG_FTRACE_SYSCALLS
  20 #include <asm/unistd.h>         /* For NR_SYSCALLS           */
  21 #include <asm/syscall.h>        /* some archs define it here */
  22 #endif
  23
  24 enum trace_type {
  25         __TRACE_FIRST_TYPE = 0,
  26
  27         TRACE_FN,
  28         TRACE_CTX,
  29         TRACE_WAKE,
  30         TRACE_STACK,
  31         TRACE_PRINT,
  32         TRACE_BPRINT,
  33         TRACE_MMIO_RW,
  34         TRACE_MMIO_MAP,
  35         TRACE_BRANCH,
  36         TRACE_GRAPH_RET,
  37         TRACE_GRAPH_ENT,
  38         TRACE_USER_STACK,
  39         TRACE_BLK,
  40         TRACE_BPUTS,
  41
  42         __TRACE_LAST_TYPE,
  43 };
  44
  45
  46 #undef __field
  47 #define __field(type, item)             type    item;
  48
  49 #undef __field_struct
  50 #define __field_struct(type, item)      __field(type, item)
  51
  52 #undef __field_desc
  53 #define __field_desc(type, container, item)
  54
  55 #undef __array
  56 #define __array(type, item, size)       type    item[size];
  57
  58 #undef __array_desc
  59 #define __array_desc(type, container, item, size)
  60
  61 #undef __dynamic_array
  62 #define __dynamic_array(type, item)     type    item[];
  63
  64 #undef F_STRUCT
  65 #define F_STRUCT(args...)               args
  66
  67 #undef FTRACE_ENTRY
  68 #define FTRACE_ENTRY(name, struct_name, id, tstruct, print, filter)     \
  69         struct struct_name {                                            \
  70                 struct trace_entry      ent;                            \
  71                 tstruct                                                 \
  72         }
  73
  74 #undef TP_ARGS
  75 #define TP_ARGS(args...)        args
  76
  77 #undef FTRACE_ENTRY_DUP
  78 #define FTRACE_ENTRY_DUP(name, name_struct, id, tstruct, printk, filter)
  79
  80 #undef FTRACE_ENTRY_REG
  81 #define FTRACE_ENTRY_REG(name, struct_name, id, tstruct, print, \
  82                          filter, regfn) \
  83         FTRACE_ENTRY(name, struct_name, id, PARAMS(tstruct), PARAMS(print), \
  84                      filter)
  85
  86 #include "trace_entries.h"
  87
  88 /*
  89  * syscalls are special, and need special handling, this is why
  90  * they are not included in trace_entries.h
  91  */
  92 struct syscall_trace_enter {
  93         struct trace_entry      ent;
  94         int                     nr;
  95         unsigned long           args[];
  96 };
  97
  98 struct syscall_trace_exit {
  99         struct trace_entry      ent;
 100         int                     nr;
 101         long                    ret;
 102 };
 103
 104 struct kprobe_trace_entry_head {
 105         struct trace_entry      ent;
 106         unsigned long           ip;
 107 };
 108
 109 struct kretprobe_trace_entry_head {
 110         struct trace_entry      ent;
 111         unsigned long           func;
 112         unsigned long           ret_ip;
 113 };
 114
 115 /*
 116  * trace_flag_type is an enumeration that holds different
 117  * states when a trace occurs. These are:
 118  *  IRQS_OFF            - interrupts were disabled
 119  *  IRQS_NOSUPPORT      - arch does not support irqs_disabled_flags
 120  *  NEED_RESCHED        - reschedule is requested
 121  *  HARDIRQ             - inside an interrupt handler
 122  *  SOFTIRQ             - inside a softirq handler
 123  */
 124 enum trace_flag_type {
 125         TRACE_FLAG_IRQS_OFF             = 0x01,
 126         TRACE_FLAG_IRQS_NOSUPPORT       = 0x02,
 127         TRACE_FLAG_NEED_RESCHED         = 0x04,
 128         TRACE_FLAG_HARDIRQ              = 0x08,
 129         TRACE_FLAG_SOFTIRQ              = 0x10,
 130         TRACE_FLAG_PREEMPT_RESCHED      = 0x20,
 131 };
 132
 133 #define TRACE_BUF_SIZE          1024
 134
 135 struct trace_array;
 136
 137 /*
 138  * The CPU trace array - it consists of thousands of trace entries
 139  * plus some other descriptor data: (for example which task started
 140  * the trace, etc.)
 141  */
 142 struct trace_array_cpu {
 143         atomic_t                disabled;
 144         void                    *buffer_page;   /* ring buffer spare */
 145
 146         unsigned long           entries;
 147         unsigned long           saved_latency;
 148         unsigned long           critical_start;
 149         unsigned long           critical_end;
 150         unsigned long           critical_sequence;
 151         unsigned long           nice;
 152         unsigned long           policy;
 153         unsigned long           rt_priority;
 154         unsigned long           skipped_entries;
 155         cycle_t                 preempt_timestamp;
 156         pid_t                   pid;
 157         kuid_t                  uid;
 158         char                    comm[TASK_COMM_LEN];
 159 };
 160
 161 struct tracer;
 162
 163 struct trace_buffer {
 164         struct trace_array              *tr;
 165         struct ring_buffer              *buffer;
 166         struct trace_array_cpu __percpu *data;
 167         cycle_t                         time_start;
 168         int                             cpu;
 169 };
 170
 171 #define TRACE_FLAGS_MAX_SIZE            32
 172
 173 /*
 174  * The trace array - an array of per-CPU trace arrays. This is the
 175  * highest level data structure that individual tracers deal with.
 176  * They have on/off state as well:
 177  */
 178 struct trace_array {
 179         struct list_head        list;
 180         char                    *name;
 181         struct trace_buffer     trace_buffer;
 182 #ifdef CONFIG_TRACER_MAX_TRACE
 183         /*
 184          * The max_buffer is used to snapshot the trace when a maximum
 185          * latency is reached, or when the user initiates a snapshot.
 186          * Some tracers will use this to store a maximum trace while
 187          * it continues examining live traces.
 188          *
 189          * The buffers for the max_buffer are set up the same as the trace_buffer
 190          * When a snapshot is taken, the buffer of the max_buffer is swapped
 191          * with the buffer of the trace_buffer and the buffers are reset for
 192          * the trace_buffer so the tracing can continue.
 193          */
 194         struct trace_buffer     max_buffer;
 195         bool                    allocated_snapshot;
 196         unsigned long           max_latency;
 197 #endif
 198         /*
 199          * max_lock is used to protect the swapping of buffers
 200          * when taking a max snapshot. The buffers themselves are
 201          * protected by per_cpu spinlocks. But the action of the swap
 202          * needs its own lock.
 203          *
 204          * This is defined as a arch_spinlock_t in order to help
 205          * with performance when lockdep debugging is enabled.
 206          *
 207          * It is also used in other places outside the update_max_tr
 208          * so it needs to be defined outside of the
 209          * CONFIG_TRACER_MAX_TRACE.
 210          */
 211         arch_spinlock_t         max_lock;
 212         int                     buffer_disabled;
 213 #ifdef CONFIG_FTRACE_SYSCALLS
 214         int                     sys_refcount_enter;
 215         int                     sys_refcount_exit;
 216         struct trace_event_file __rcu *enter_syscall_files[NR_syscalls];
 217         struct trace_event_file __rcu *exit_syscall_files[NR_syscalls];
 218 #endif
 219         int                     stop_count;
 220         int                     clock_id;
 221         struct tracer           *current_trace;
 222         unsigned int            trace_flags;
 223         unsigned char           trace_flags_index[TRACE_FLAGS_MAX_SIZE];
 224         unsigned int            flags;
 225         raw_spinlock_t          start_lock;
 226         struct dentry           *dir;
 227         struct dentry           *options;
 228         struct dentry           *percpu_dir;
 229         struct dentry           *event_dir;
 230         struct list_head        systems;
 231         struct list_head        events;
 232         cpumask_var_t           tracing_cpumask; /* only trace on set CPUs */
 233         int                     ref;
 234 #ifdef CONFIG_FUNCTION_TRACER
 235         struct ftrace_ops       *ops;
 236         /* function tracing enabled */
 237         int                     function_enabled;
 238 #endif
 239 };
 240
 241 enum {
 242         TRACE_ARRAY_FL_GLOBAL   = (1 << 0)
 243 };
 244
 245 extern struct list_head ftrace_trace_arrays;
 246
 247 extern struct mutex trace_types_lock;
 248
 249 extern int trace_array_get(struct trace_array *tr);
 250 extern void trace_array_put(struct trace_array *tr);
 251
 252 /*
 253  * The global tracer (top) should be the first trace array added,
 254  * but we check the flag anyway.
 255  */
 256 static inline struct trace_array *top_trace_array(void)
 257 {
 258         struct trace_array *tr;
 259
 260         if (list_empty(&ftrace_trace_arrays))
 261                 return NULL;
 262
 263         tr = list_entry(ftrace_trace_arrays.prev,
 264                         typeof(*tr), list);
 265         WARN_ON(!(tr->flags & TRACE_ARRAY_FL_GLOBAL));
 266         return tr;
 267 }
 268
 269 #define FTRACE_CMP_TYPE(var, type) \
 270         __builtin_types_compatible_p(typeof(var), type *)
 271
 272 #undef IF_ASSIGN
 273 #define IF_ASSIGN(var, entry, etype, id)                \
 274         if (FTRACE_CMP_TYPE(var, etype)) {              \
 275                 var = (typeof(var))(entry);             \
 276                 WARN_ON(id && (entry)->type != id);     \
 277                 break;                                  \
 278         }
 279
 280 /* Will cause compile errors if type is not found. */
 281 extern void __ftrace_bad_type(void);
 282
 283 /*
 284  * The trace_assign_type is a verifier that the entry type is
 285  * the same as the type being assigned. To add new types simply
 286  * add a line with the following format:
 287  *
 288  * IF_ASSIGN(var, ent, type, id);
 289  *
 290  *  Where "type" is the trace type that includes the trace_entry
 291  *  as the "ent" item. And "id" is the trace identifier that is
 292  *  used in the trace_type enum.
 293  *
 294  *  If the type can have more than one id, then use zero.
 295  */
 296 #define trace_assign_type(var, ent)                                     \
 297         do {                                                            \
 298                 IF_ASSIGN(var, ent, struct ftrace_entry, TRACE_FN);     \
 299                 IF_ASSIGN(var, ent, struct ctx_switch_entry, 0);        \
 300                 IF_ASSIGN(var, ent, struct stack_entry, TRACE_STACK);   \
 301                 IF_ASSIGN(var, ent, struct userstack_entry, TRACE_USER_STACK);\
 302                 IF_ASSIGN(var, ent, struct print_entry, TRACE_PRINT);   \
 303                 IF_ASSIGN(var, ent, struct bprint_entry, TRACE_BPRINT); \
 304                 IF_ASSIGN(var, ent, struct bputs_entry, TRACE_BPUTS);   \
 305                 IF_ASSIGN(var, ent, struct trace_mmiotrace_rw,          \
 306                           TRACE_MMIO_RW);                               \
 307                 IF_ASSIGN(var, ent, struct trace_mmiotrace_map,         \
 308                           TRACE_MMIO_MAP);                              \
 309                 IF_ASSIGN(var, ent, struct trace_branch, TRACE_BRANCH); \
 310                 IF_ASSIGN(var, ent, struct ftrace_graph_ent_entry,      \
 311                           TRACE_GRAPH_ENT);             \
 312                 IF_ASSIGN(var, ent, struct ftrace_graph_ret_entry,      \
 313                           TRACE_GRAPH_RET);             \
 314                 __ftrace_bad_type();                                    \
 315         } while (0)
 316
 317 /*
 318  * An option specific to a tracer. This is a boolean value.
 319  * The bit is the bit index that sets its value on the
 320  * flags value in struct tracer_flags.
 321  */
 322 struct tracer_opt {
 323         const char      *name; /* Will appear on the trace_options file */
 324         u32             bit; /* Mask assigned in val field in tracer_flags */
 325 };
 326
 327 /*
 328  * The set of specific options for a tracer. Your tracer
 329  * have to set the initial value of the flags val.
 330  */
 331 struct tracer_flags {
 332         u32                     val;
 333         struct tracer_opt       *opts;
 334 };
 335
 336 /* Makes more easy to define a tracer opt */
 337 #define TRACER_OPT(s, b)        .name = #s, .bit = b
 338
 339
 340 struct trace_option_dentry {
 341         struct tracer_opt               *opt;
 342         struct tracer_flags             *flags;
 343         struct trace_array              *tr;
 344         struct dentry                   *entry;
 345 };
 346
 347 /**
 348  * struct tracer - a specific tracer and its callbacks to interact with tracefs
 349  * @name: the name chosen to select it on the available_tracers file
 350  * @init: called when one switches to this tracer (echo name > current_tracer)
 351  * @reset: called when one switches to another tracer
 352  * @start: called when tracing is unpaused (echo 1 > tracing_enabled)
 353  * @stop: called when tracing is paused (echo 0 > tracing_enabled)
 354  * @update_thresh: called when tracing_thresh is updated
 355  * @open: called when the trace file is opened
 356  * @pipe_open: called when the trace_pipe file is opened
 357  * @close: called when the trace file is released
 358  * @pipe_close: called when the trace_pipe file is released
 359  * @read: override the default read callback on trace_pipe
 360  * @splice_read: override the default splice_read callback on trace_pipe
 361  * @selftest: selftest to run on boot (see trace_selftest.c)
 362  * @print_headers: override the first lines that describe your columns
 363  * @print_line: callback that prints a trace
 364  * @set_flag: signals one of your private flags changed (trace_options file)
 365  * @flags: your private flags
 366  */
 367 struct tracer {
 368         const char              *name;
 369         int                     (*init)(struct trace_array *tr);
 370         void                    (*reset)(struct trace_array *tr);
 371         void                    (*start)(struct trace_array *tr);
 372         void                    (*stop)(struct trace_array *tr);
 373         int                     (*update_thresh)(struct trace_array *tr);
 374         void                    (*open)(struct trace_iterator *iter);
 375         void                    (*pipe_open)(struct trace_iterator *iter);
 376         void                    (*close)(struct trace_iterator *iter);
 377         void                    (*pipe_close)(struct trace_iterator *iter);
 378         ssize_t                 (*read)(struct trace_iterator *iter,
 379                                         struct file *filp, char __user *ubuf,
 380                                         size_t cnt, loff_t *ppos);
 381         ssize_t                 (*splice_read)(struct trace_iterator *iter,
 382                                                struct file *filp,
 383                                                loff_t *ppos,
 384                                                struct pipe_inode_info *pipe,
 385                                                size_t len,
 386                                                unsigned int flags);
 387 #ifdef CONFIG_FTRACE_STARTUP_TEST
 388         int                     (*selftest)(struct tracer *trace,
 389                                             struct trace_array *tr);
 390 #endif
 391         void                    (*print_header)(struct seq_file *m);
 392         enum print_line_t       (*print_line)(struct trace_iterator *iter);
 393         /* If you handled the flag setting, return 0 */
 394         int                     (*set_flag)(struct trace_array *tr,
 395                                             u32 old_flags, u32 bit, int set);
 396         /* Return 0 if OK with change, else return non-zero */
 397         int                     (*flag_changed)(struct trace_array *tr,
 398                                                 u32 mask, int set);
 399         struct tracer           *next;
 400         struct tracer_flags     *flags;
 401         struct trace_option_dentry *topts;
 402         int                     enabled;
 403         int                     ref;
 404         bool                    print_max;
 405         bool                    allow_instances;
 406 #ifdef CONFIG_TRACER_MAX_TRACE
 407         bool                    use_max_tr;
 408 #endif
 409 };
 410
 411
 412 /* Only current can touch trace_recursion */
 413
 414 /*
 415  * For function tracing recursion:
 416  *  The order of these bits are important.
 417  *
 418  *  When function tracing occurs, the following steps are made:
 419  *   If arch does not support a ftrace feature:
 420  *    call internal function (uses INTERNAL bits) which calls...
 421  *   If callback is registered to the "global" list, the list
 422  *    function is called and recursion checks the GLOBAL bits.
 423  *    then this function calls...
 424  *   The function callback, which can use the FTRACE bits to
 425  *    check for recursion.
 426  *
 427  * Now if the arch does not suppport a feature, and it calls
 428  * the global list function which calls the ftrace callback
 429  * all three of these steps will do a recursion protection.
 430  * There's no reason to do one if the previous caller already
 431  * did. The recursion that we are protecting against will
 432  * go through the same steps again.
 433  *
 434  * To prevent the multiple recursion checks, if a recursion
 435  * bit is set that is higher than the MAX bit of the current
 436  * check, then we know that the check was made by the previous
 437  * caller, and we can skip the current check.
 438  */
 439 enum {
 440         TRACE_BUFFER_BIT,
 441         TRACE_BUFFER_NMI_BIT,
 442         TRACE_BUFFER_IRQ_BIT,
 443         TRACE_BUFFER_SIRQ_BIT,
 444
 445         /* Start of function recursion bits */
 446         TRACE_FTRACE_BIT,
 447         TRACE_FTRACE_NMI_BIT,
 448         TRACE_FTRACE_IRQ_BIT,
 449         TRACE_FTRACE_SIRQ_BIT,
 450
 451         /* INTERNAL_BITs must be greater than FTRACE_BITs */
 452         TRACE_INTERNAL_BIT,
 453         TRACE_INTERNAL_NMI_BIT,
 454         TRACE_INTERNAL_IRQ_BIT,
 455         TRACE_INTERNAL_SIRQ_BIT,
 456
 457         TRACE_CONTROL_BIT,
 458
 459         TRACE_BRANCH_BIT,
 460 /*
 461  * Abuse of the trace_recursion.
 462  * As we need a way to maintain state if we are tracing the function
 463  * graph in irq because we want to trace a particular function that
 464  * was called in irq context but we have irq tracing off. Since this
 465  * can only be modified by current, we can reuse trace_recursion.
 466  */
 467         TRACE_IRQ_BIT,
 468 };
 469
 470 #define trace_recursion_set(bit)        do { (current)->trace_recursion |= (1<<(bit)); } while (0)
 471 #define trace_recursion_clear(bit)      do { (current)->trace_recursion &= ~(1<<(bit)); } while (0)
 472 #define trace_recursion_test(bit)       ((current)->trace_recursion & (1<<(bit)))
 473
 474 #define TRACE_CONTEXT_BITS      4
 475
 476 #define TRACE_FTRACE_START      TRACE_FTRACE_BIT
 477 #define TRACE_FTRACE_MAX        ((1 << (TRACE_FTRACE_START + TRACE_CONTEXT_BITS)) - 1)
 478
 479 #define TRACE_LIST_START        TRACE_INTERNAL_BIT
 480 #define TRACE_LIST_MAX          ((1 << (TRACE_LIST_START + TRACE_CONTEXT_BITS)) - 1)
 481
 482 #define TRACE_CONTEXT_MASK      TRACE_LIST_MAX
 483
 484 static __always_inline int trace_get_context_bit(void)
 485 {
 486         int bit;
 487
 488         if (in_interrupt()) {
 489                 if (in_nmi())
 490                         bit = 0;
 491
 492                 else if (in_irq())
 493                         bit = 1;
 494                 else
 495                         bit = 2;
 496         } else
 497                 bit = 3;
 498
 499         return bit;
 500 }
 501
 502 static __always_inline int trace_test_and_set_recursion(int start, int max)
 503 {
 504         unsigned int val = current->trace_recursion;
 505         int bit;
 506
 507         /* A previous recursion check was made */
 508         if ((val & TRACE_CONTEXT_MASK) > max)
 509                 return 0;
 510
 511         bit = trace_get_context_bit() + start;
 512         if (unlikely(val & (1 << bit)))
 513                 return -1;
 514
 515         val |= 1 << bit;
 516         current->trace_recursion = val;
 517         barrier();
 518
 519         return bit;
 520 }
 521
 522 static __always_inline void trace_clear_recursion(int bit)
 523 {
 524         unsigned int val = current->trace_recursion;
 525
 526         if (!bit)
 527                 return;
 528
 529         bit = 1 << bit;
 530         val &= ~bit;
 531
 532         barrier();
 533         current->trace_recursion = val;
 534 }
 535
 536 static inline struct ring_buffer_iter *
 537 trace_buffer_iter(struct trace_iterator *iter, int cpu)
 538 {
 539         if (iter->buffer_iter && iter->buffer_iter[cpu])
 540                 return iter->buffer_iter[cpu];
 541         return NULL;
 542 }
 543
 544 int tracer_init(struct tracer *t, struct trace_array *tr);
 545 int tracing_is_enabled(void);
 546 void tracing_reset(struct trace_buffer *buf, int cpu);
 547 void tracing_reset_online_cpus(struct trace_buffer *buf);
 548 void tracing_reset_current(int cpu);
 549 void tracing_reset_all_online_cpus(void);
 550 int tracing_open_generic(struct inode *inode, struct file *filp);
 551 bool tracing_is_disabled(void);
 552 struct dentry *trace_create_file(const char *name,
 553                                  umode_t mode,
 554                                  struct dentry *parent,
 555                                  void *data,
 556                                  const struct file_operations *fops);
 557
 558 struct dentry *tracing_init_dentry(void);
 559
 560 struct ring_buffer_event;
 561
 562 struct ring_buffer_event *
 563 trace_buffer_lock_reserve(struct ring_buffer *buffer,
 564                           int type,
 565                           unsigned long len,
 566                           unsigned long flags,
 567                           int pc);
 568
 569 struct trace_entry *tracing_get_trace_entry(struct trace_array *tr,
 570                                                 struct trace_array_cpu *data);
 571
 572 struct trace_entry *trace_find_next_entry(struct trace_iterator *iter,
 573                                           int *ent_cpu, u64 *ent_ts);
 574
 575 void __buffer_unlock_commit(struct ring_buffer *buffer,
 576                             struct ring_buffer_event *event);
 577
 578 int trace_empty(struct trace_iterator *iter);
 579
 580 void *trace_find_next_entry_inc(struct trace_iterator *iter);
 581
 582 void trace_init_global_iter(struct trace_iterator *iter);
 583
 584 void tracing_iter_reset(struct trace_iterator *iter, int cpu);
 585
 586 void trace_function(struct trace_array *tr,
 587                     unsigned long ip,
 588                     unsigned long parent_ip,
 589                     unsigned long flags, int pc);
 590 void trace_graph_function(struct trace_array *tr,
 591                     unsigned long ip,
 592                     unsigned long parent_ip,
 593                     unsigned long flags, int pc);
 594 void trace_latency_header(struct seq_file *m);
 595 void trace_default_header(struct seq_file *m);
 596 void print_trace_header(struct seq_file *m, struct trace_iterator *iter);
 597 int trace_empty(struct trace_iterator *iter);
 598
 599 void trace_graph_return(struct ftrace_graph_ret *trace);
 600 int trace_graph_entry(struct ftrace_graph_ent *trace);
 601 void set_graph_array(struct trace_array *tr);
 602
 603 void tracing_start_cmdline_record(void);
 604 void tracing_stop_cmdline_record(void);
 605 int register_tracer(struct tracer *type);
 606 int is_tracing_stopped(void);
 607
 608 loff_t tracing_lseek(struct file *file, loff_t offset, int whence);
 609
 610 extern cpumask_var_t __read_mostly tracing_buffer_mask;
 611
 612 #define for_each_tracing_cpu(cpu)       \
 613         for_each_cpu(cpu, tracing_buffer_mask)
 614
 615 extern unsigned long nsecs_to_usecs(unsigned long nsecs);
 616
 617 extern unsigned long tracing_thresh;
 618
 619 #ifdef CONFIG_TRACER_MAX_TRACE
 620 void update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu);
 621 void update_max_tr_single(struct trace_array *tr,
 622                           struct task_struct *tsk, int cpu);
 623 #endif /* CONFIG_TRACER_MAX_TRACE */
 624
 625 #ifdef CONFIG_STACKTRACE
 626 void ftrace_trace_userstack(struct ring_buffer *buffer, unsigned long flags,
 627                             int pc);
 628
 629 void __trace_stack(struct trace_array *tr, unsigned long flags, int skip,
 630                    int pc);
 631 #else
 632 static inline void ftrace_trace_userstack(struct ring_buffer *buffer,
 633                                           unsigned long flags, int pc)
 634 {
 635 }
 636
 637 static inline void __trace_stack(struct trace_array *tr, unsigned long flags,
 638                                  int skip, int pc)
 639 {
 640 }
 641 #endif /* CONFIG_STACKTRACE */
 642
 643 extern cycle_t ftrace_now(int cpu);
 644
 645 extern void trace_find_cmdline(int pid, char comm[]);
 646
 647 #ifdef CONFIG_DYNAMIC_FTRACE
 648 extern unsigned long ftrace_update_tot_cnt;
 649 #endif
 650 #define DYN_FTRACE_TEST_NAME trace_selftest_dynamic_test_func
 651 extern int DYN_FTRACE_TEST_NAME(void);
 652 #define DYN_FTRACE_TEST_NAME2 trace_selftest_dynamic_test_func2
 653 extern int DYN_FTRACE_TEST_NAME2(void);
 654
 655 extern bool ring_buffer_expanded;
 656 extern bool tracing_selftest_disabled;
 657 DECLARE_PER_CPU(int, ftrace_cpu_disabled);
 658
 659 #ifdef CONFIG_FTRACE_STARTUP_TEST
 660 extern int trace_selftest_startup_function(struct tracer *trace,
 661                                            struct trace_array *tr);
 662 extern int trace_selftest_startup_function_graph(struct tracer *trace,
 663                                                  struct trace_array *tr);
 664 extern int trace_selftest_startup_irqsoff(struct tracer *trace,
 665                                           struct trace_array *tr);
 666 extern int trace_selftest_startup_preemptoff(struct tracer *trace,
 667                                              struct trace_array *tr);
 668 extern int trace_selftest_startup_preemptirqsoff(struct tracer *trace,
 669                                                  struct trace_array *tr);
 670 extern int trace_selftest_startup_wakeup(struct tracer *trace,
 671                                          struct trace_array *tr);
 672 extern int trace_selftest_startup_nop(struct tracer *trace,
 673                                          struct trace_array *tr);
 674 extern int trace_selftest_startup_sched_switch(struct tracer *trace,
 675                                                struct trace_array *tr);
 676 extern int trace_selftest_startup_branch(struct tracer *trace,
 677                                          struct trace_array *tr);
 678 /*
 679  * Tracer data references selftest functions that only occur
 680  * on boot up. These can be __init functions. Thus, when selftests
 681  * are enabled, then the tracers need to reference __init functions.
 682  */
 683 #define __tracer_data           __refdata
 684 #else
 685 /* Tracers are seldom changed. Optimize when selftests are disabled. */
 686 #define __tracer_data           __read_mostly
 687 #endif /* CONFIG_FTRACE_STARTUP_TEST */
 688
 689 extern void *head_page(struct trace_array_cpu *data);
 690 extern unsigned long long ns2usecs(cycle_t nsec);
 691 extern int
 692 trace_vbprintk(unsigned long ip, const char *fmt, va_list args);
 693 extern int
 694 trace_vprintk(unsigned long ip, const char *fmt, va_list args);
 695 extern int
 696 trace_array_vprintk(struct trace_array *tr,
 697                     unsigned long ip, const char *fmt, va_list args);
 698 int trace_array_printk(struct trace_array *tr,
 699                        unsigned long ip, const char *fmt, ...);
 700 int trace_array_printk_buf(struct ring_buffer *buffer,
 701                            unsigned long ip, const char *fmt, ...);
 702 void trace_printk_seq(struct trace_seq *s);
 703 enum print_line_t print_trace_line(struct trace_iterator *iter);
 704
 705 extern char trace_find_mark(unsigned long long duration);
 706
 707 /* Standard output formatting function used for function return traces */
 708 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 709
 710 /* Flag options */
 711 #define TRACE_GRAPH_PRINT_OVERRUN       0x1
 712 #define TRACE_GRAPH_PRINT_CPU           0x2
 713 #define TRACE_GRAPH_PRINT_OVERHEAD      0x4
 714 #define TRACE_GRAPH_PRINT_PROC          0x8
 715 #define TRACE_GRAPH_PRINT_DURATION      0x10
 716 #define TRACE_GRAPH_PRINT_ABS_TIME      0x20
 717 #define TRACE_GRAPH_PRINT_IRQS          0x40
 718 #define TRACE_GRAPH_PRINT_TAIL          0x80
 719 #define TRACE_GRAPH_SLEEP_TIME          0x100
 720 #define TRACE_GRAPH_GRAPH_TIME          0x200
 721 #define TRACE_GRAPH_PRINT_FILL_SHIFT    28
 722 #define TRACE_GRAPH_PRINT_FILL_MASK     (0x3 << TRACE_GRAPH_PRINT_FILL_SHIFT)
 723
 724 extern void ftrace_graph_sleep_time_control(bool enable);
 725 extern void ftrace_graph_graph_time_control(bool enable);
 726
 727 extern enum print_line_t
 728 print_graph_function_flags(struct trace_iterator *iter, u32 flags);
 729 extern void print_graph_headers_flags(struct seq_file *s, u32 flags);
 730 extern void
 731 trace_print_graph_duration(unsigned long long duration, struct trace_seq *s);
 732 extern void graph_trace_open(struct trace_iterator *iter);
 733 extern void graph_trace_close(struct trace_iterator *iter);
 734 extern int __trace_graph_entry(struct trace_array *tr,
 735                                struct ftrace_graph_ent *trace,
 736                                unsigned long flags, int pc);
 737 extern void __trace_graph_return(struct trace_array *tr,
 738                                  struct ftrace_graph_ret *trace,
 739                                  unsigned long flags, int pc);
 740
 741
 742 #ifdef CONFIG_DYNAMIC_FTRACE
 743 /* TODO: make this variable */
 744 #define FTRACE_GRAPH_MAX_FUNCS          32
 745 extern int ftrace_graph_count;
 746 extern unsigned long ftrace_graph_funcs[FTRACE_GRAPH_MAX_FUNCS];
 747 extern int ftrace_graph_notrace_count;
 748 extern unsigned long ftrace_graph_notrace_funcs[FTRACE_GRAPH_MAX_FUNCS];
 749
 750 static inline int ftrace_graph_addr(unsigned long addr)
 751 {
 752         int i;
 753
 754         if (!ftrace_graph_count)
 755                 return 1;
 756
 757         for (i = 0; i < ftrace_graph_count; i++) {
 758                 if (addr == ftrace_graph_funcs[i]) {
 759                         /*
 760                          * If no irqs are to be traced, but a set_graph_function
 761                          * is set, and called by an interrupt handler, we still
 762                          * want to trace it.
 763                          */
 764                         if (in_irq())
 765                                 trace_recursion_set(TRACE_IRQ_BIT);
 766                         else
 767                                 trace_recursion_clear(TRACE_IRQ_BIT);
 768                         return 1;
 769                 }
 770         }
 771
 772         return 0;
 773 }
 774
 775 static inline int ftrace_graph_notrace_addr(unsigned long addr)
 776 {
 777         int i;
 778
 779         if (!ftrace_graph_notrace_count)
 780                 return 0;
 781
 782         for (i = 0; i < ftrace_graph_notrace_count; i++) {
 783                 if (addr == ftrace_graph_notrace_funcs[i])
 784                         return 1;
 785         }
 786
 787         return 0;
 788 }
 789 #else
 790 static inline int ftrace_graph_addr(unsigned long addr)
 791 {
 792         return 1;
 793 }
 794
 795 static inline int ftrace_graph_notrace_addr(unsigned long addr)
 796 {
 797         return 0;
 798 }
 799 #endif /* CONFIG_DYNAMIC_FTRACE */
 800 #else /* CONFIG_FUNCTION_GRAPH_TRACER */
 801 static inline enum print_line_t
 802 print_graph_function_flags(struct trace_iterator *iter, u32 flags)
 803 {
 804         return TRACE_TYPE_UNHANDLED;
 805 }
 806 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
 807
 808 extern struct list_head ftrace_pids;
 809
 810 #ifdef CONFIG_FUNCTION_TRACER
 811 extern bool ftrace_filter_param __initdata;
 812 static inline int ftrace_trace_task(struct task_struct *task)
 813 {
 814         if (list_empty(&ftrace_pids))
 815                 return 1;
 816
 817         return test_tsk_trace_trace(task);
 818 }
 819 extern int ftrace_is_dead(void);
 820 int ftrace_create_function_files(struct trace_array *tr,
 821                                  struct dentry *parent);
 822 void ftrace_destroy_function_files(struct trace_array *tr);
 823 void ftrace_init_global_array_ops(struct trace_array *tr);
 824 void ftrace_init_array_ops(struct trace_array *tr, ftrace_func_t func);
 825 void ftrace_reset_array_ops(struct trace_array *tr);
 826 int using_ftrace_ops_list_func(void);
 827 #else
 828 static inline int ftrace_trace_task(struct task_struct *task)
 829 {
 830         return 1;
 831 }
 832 static inline int ftrace_is_dead(void) { return 0; }
 833 static inline int
 834 ftrace_create_function_files(struct trace_array *tr,
 835                              struct dentry *parent)
 836 {
 837         return 0;
 838 }
 839 static inline void ftrace_destroy_function_files(struct trace_array *tr) { }
 840 static inline __init void
 841 ftrace_init_global_array_ops(struct trace_array *tr) { }
 842 static inline void ftrace_reset_array_ops(struct trace_array *tr) { }
 843 /* ftace_func_t type is not defined, use macro instead of static inline */
 844 #define ftrace_init_array_ops(tr, func) do { } while (0)
 845 #endif /* CONFIG_FUNCTION_TRACER */
 846
 847 #if defined(CONFIG_FUNCTION_TRACER) && defined(CONFIG_DYNAMIC_FTRACE)
 848 void ftrace_create_filter_files(struct ftrace_ops *ops,
 849                                 struct dentry *parent);
 850 void ftrace_destroy_filter_files(struct ftrace_ops *ops);
 851 #else
 852 /*
 853  * The ops parameter passed in is usually undefined.
 854  * This must be a macro.
 855  */
 856 #define ftrace_create_filter_files(ops, parent) do { } while (0)
 857 #define ftrace_destroy_filter_files(ops) do { } while (0)
 858 #endif /* CONFIG_FUNCTION_TRACER && CONFIG_DYNAMIC_FTRACE */
 859
 860 int ftrace_event_is_function(struct trace_event_call *call);
 861
 862 /*
 863  * struct trace_parser - servers for reading the user input separated by spaces
 864  * @cont: set if the input is not complete - no final space char was found
 865  * @buffer: holds the parsed user input
 866  * @idx: user input length
 867  * @size: buffer size
 868  */
 869 struct trace_parser {
 870         bool            cont;
 871         char            *buffer;
 872         unsigned        idx;
 873         unsigned        size;
 874 };
 875
 876 static inline bool trace_parser_loaded(struct trace_parser *parser)
 877 {
 878         return (parser->idx != 0);
 879 }
 880
 881 static inline bool trace_parser_cont(struct trace_parser *parser)
 882 {
 883         return parser->cont;
 884 }
 885
 886 static inline void trace_parser_clear(struct trace_parser *parser)
 887 {
 888         parser->cont = false;
 889         parser->idx = 0;
 890 }
 891
 892 extern int trace_parser_get_init(struct trace_parser *parser, int size);
 893 extern void trace_parser_put(struct trace_parser *parser);
 894 extern int trace_get_user(struct trace_parser *parser, const char __user *ubuf,
 895         size_t cnt, loff_t *ppos);
 896
 897 /*
 898  * Only create function graph options if function graph is configured.
 899  */
 900 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 901 # define FGRAPH_FLAGS                                           \
 902                 C(DISPLAY_GRAPH,        "display-graph"),
 903 #else
 904 # define FGRAPH_FLAGS
 905 #endif
 906
 907 #ifdef CONFIG_BRANCH_TRACER
 908 # define BRANCH_FLAGS                                   \
 909                 C(BRANCH,               "branch"),
 910 #else
 911 # define BRANCH_FLAGS
 912 #endif
 913
 914 #ifdef CONFIG_FUNCTION_TRACER
 915 # define FUNCTION_FLAGS                                         \
 916                 C(FUNCTION,             "function-trace"),
 917 # define FUNCTION_DEFAULT_FLAGS         TRACE_ITER_FUNCTION
 918 #else
 919 # define FUNCTION_FLAGS
 920 # define FUNCTION_DEFAULT_FLAGS         0UL
 921 #endif
 922
 923 #ifdef CONFIG_STACKTRACE
 924 # define STACK_FLAGS                            \
 925                 C(STACKTRACE,           "stacktrace"),
 926 #else
 927 # define STACK_FLAGS
 928 #endif
 929
 930 /*
 931  * trace_iterator_flags is an enumeration that defines bit
 932  * positions into trace_flags that controls the output.
 933  *
 934  * NOTE: These bits must match the trace_options array in
 935  *       trace.c (this macro guarantees it).
 936  */
 937 #define TRACE_FLAGS                                             \
 938                 C(PRINT_PARENT,         "print-parent"),        \
 939                 C(SYM_OFFSET,           "sym-offset"),          \
 940                 C(SYM_ADDR,             "sym-addr"),            \
 941                 C(VERBOSE,              "verbose"),             \
 942                 C(RAW,                  "raw"),                 \
 943                 C(HEX,                  "hex"),                 \
 944                 C(BIN,                  "bin"),                 \
 945                 C(BLOCK,                "block"),               \
 946                 C(PRINTK,               "trace_printk"),        \
 947                 C(ANNOTATE,             "annotate"),            \
 948                 C(USERSTACKTRACE,       "userstacktrace"),      \
 949                 C(SYM_USEROBJ,          "sym-userobj"),         \
 950                 C(PRINTK_MSGONLY,       "printk-msg-only"),     \
 951                 C(CONTEXT_INFO,         "context-info"),   /* Print pid/cpu/time */ \
 952                 C(LATENCY_FMT,          "latency-format"),      \
 953                 C(RECORD_CMD,           "record-cmd"),          \
 954                 C(OVERWRITE,            "overwrite"),           \
 955                 C(STOP_ON_FREE,         "disable_on_free"),     \
 956                 C(IRQ_INFO,             "irq-info"),            \
 957                 C(MARKERS,              "markers"),             \
 958                 FUNCTION_FLAGS                                  \
 959                 FGRAPH_FLAGS                                    \
 960                 STACK_FLAGS                                     \
 961                 BRANCH_FLAGS
 962
 963 /*
 964  * By defining C, we can make TRACE_FLAGS a list of bit names
 965  * that will define the bits for the flag masks.
 966  */
 967 #undef C
 968 #define C(a, b) TRACE_ITER_##a##_BIT
 969
 970 enum trace_iterator_bits {
 971         TRACE_FLAGS
 972         /* Make sure we don't go more than we have bits for */
 973         TRACE_ITER_LAST_BIT
 974 };
 975
 976 /*
 977  * By redefining C, we can make TRACE_FLAGS a list of masks that
 978  * use the bits as defined above.
 979  */
 980 #undef C
 981 #define C(a, b) TRACE_ITER_##a = (1 << TRACE_ITER_##a##_BIT)
 982
 983 enum trace_iterator_flags { TRACE_FLAGS };
 984
 985 /*
 986  * TRACE_ITER_SYM_MASK masks the options in trace_flags that
 987  * control the output of kernel symbols.
 988  */
 989 #define TRACE_ITER_SYM_MASK \
 990         (TRACE_ITER_PRINT_PARENT|TRACE_ITER_SYM_OFFSET|TRACE_ITER_SYM_ADDR)
 991
 992 extern struct tracer nop_trace;
 993
 994 #ifdef CONFIG_BRANCH_TRACER
 995 extern int enable_branch_tracing(struct trace_array *tr);
 996 extern void disable_branch_tracing(void);
 997 static inline int trace_branch_enable(struct trace_array *tr)
 998 {
 999         if (tr->trace_flags & TRACE_ITER_BRANCH)
1000                 return enable_branch_tracing(tr);
1001         return 0;
1002 }
1003 static inline void trace_branch_disable(void)
1004 {
1005         /* due to races, always disable */
1006         disable_branch_tracing();
1007 }
1008 #else
1009 static inline int trace_branch_enable(struct trace_array *tr)
1010 {
1011         return 0;
1012 }
1013 static inline void trace_branch_disable(void)
1014 {
1015 }
1016 #endif /* CONFIG_BRANCH_TRACER */
1017
1018 /* set ring buffers to default size if not already done so */
1019 int tracing_update_buffers(void);
1020
1021 struct ftrace_event_field {
1022         struct list_head        link;
1023         const char              *name;
1024         const char              *type;
1025         int                     filter_type;
1026         int                     offset;
1027         int                     size;
1028         int                     is_signed;
1029 };
1030
1031 struct event_filter {
1032         int                     n_preds;        /* Number assigned */
1033         int                     a_preds;        /* allocated */
1034         struct filter_pred      *preds;
1035         struct filter_pred      *root;
1036         char                    *filter_string;
1037 };
1038
1039 struct event_subsystem {
1040         struct list_head        list;
1041         const char              *name;
1042         struct event_filter     *filter;
1043         int                     ref_count;
1044 };
1045
1046 struct trace_subsystem_dir {
1047         struct list_head                list;
1048         struct event_subsystem          *subsystem;
1049         struct trace_array              *tr;
1050         struct dentry                   *entry;
1051         int                             ref_count;
1052         int                             nr_events;
1053 };
1054
1055 #define FILTER_PRED_INVALID     ((unsigned short)-1)
1056 #define FILTER_PRED_IS_RIGHT    (1 << 15)
1057 #define FILTER_PRED_FOLD        (1 << 15)
1058
1059 /*
1060  * The max preds is the size of unsigned short with
1061  * two flags at the MSBs. One bit is used for both the IS_RIGHT
1062  * and FOLD flags. The other is reserved.
1063  *
1064  * 2^14 preds is way more than enough.
1065  */
1066 #define MAX_FILTER_PRED         16384
1067
1068 struct filter_pred;
1069 struct regex;
1070
1071 typedef int (*filter_pred_fn_t) (struct filter_pred *pred, void *event);
1072
1073 typedef int (*regex_match_func)(char *str, struct regex *r, int len);
1074
1075 enum regex_type {
1076         MATCH_FULL = 0,
1077         MATCH_FRONT_ONLY,
1078         MATCH_MIDDLE_ONLY,
1079         MATCH_END_ONLY,
1080 };
1081
1082 struct regex {
1083         char                    pattern[MAX_FILTER_STR_VAL];
1084         int                     len;
1085         int                     field_len;
1086         regex_match_func        match;
1087 };
1088
1089 struct filter_pred {
1090         filter_pred_fn_t        fn;
1091         u64                     val;
1092         struct regex            regex;
1093         unsigned short          *ops;
1094         struct ftrace_event_field *field;
1095         int                     offset;
1096         int                     not;
1097         int                     op;
1098         unsigned short          index;
1099         unsigned short          parent;
1100         unsigned short          left;
1101         unsigned short          right;
1102 };
1103
1104 extern enum regex_type
1105 filter_parse_regex(char *buff, int len, char **search, int *not);
1106 extern void print_event_filter(struct trace_event_file *file,
1107                                struct trace_seq *s);
1108 extern int apply_event_filter(struct trace_event_file *file,
1109                               char *filter_string);
1110 extern int apply_subsystem_event_filter(struct trace_subsystem_dir *dir,
1111                                         char *filter_string);
1112 extern void print_subsystem_event_filter(struct event_subsystem *system,
1113                                          struct trace_seq *s);
1114 extern int filter_assign_type(const char *type);
1115 extern int create_event_filter(struct trace_event_call *call,
1116                                char *filter_str, bool set_str,
1117                                struct event_filter **filterp);
1118 extern void free_event_filter(struct event_filter *filter);
1119
1120 struct ftrace_event_field *
1121 trace_find_event_field(struct trace_event_call *call, char *name);
1122
1123 extern void trace_event_enable_cmd_record(bool enable);
1124 extern int event_trace_add_tracer(struct dentry *parent, struct trace_array *tr);
1125 extern int event_trace_del_tracer(struct trace_array *tr);
1126
1127 extern struct trace_event_file *find_event_file(struct trace_array *tr,
1128                                                 const char *system,
1129                                                 const char *event);
1130
1131 static inline void *event_file_data(struct file *filp)
1132 {
1133         return ACCESS_ONCE(file_inode(filp)->i_private);
1134 }
1135
1136 extern struct mutex event_mutex;
1137 extern struct list_head ftrace_events;
1138
1139 extern const struct file_operations event_trigger_fops;
1140
1141 extern int register_trigger_cmds(void);
1142 extern void clear_event_triggers(struct trace_array *tr);
1143
1144 struct event_trigger_data {
1145         unsigned long                   count;
1146         int                             ref;
1147         struct event_trigger_ops        *ops;
1148         struct event_command            *cmd_ops;
1149         struct event_filter __rcu       *filter;
1150         char                            *filter_str;
1151         void                            *private_data;
1152         struct list_head                list;
1153 };
1154
1155 /**
1156  * struct event_trigger_ops - callbacks for trace event triggers
1157  *
1158  * The methods in this structure provide per-event trigger hooks for
1159  * various trigger operations.
1160  *
1161  * All the methods below, except for @init() and @free(), must be
1162  * implemented.
1163  *
1164  * @func: The trigger 'probe' function called when the triggering
1165  *      event occurs.  The data passed into this callback is the data
1166  *      that was supplied to the event_command @reg() function that
1167  *      registered the trigger (see struct event_command).
1168  *
1169  * @init: An optional initialization function called for the trigger
1170  *      when the trigger is registered (via the event_command reg()
1171  *      function).  This can be used to perform per-trigger
1172  *      initialization such as incrementing a per-trigger reference
1173  *      count, for instance.  This is usually implemented by the
1174  *      generic utility function @event_trigger_init() (see
1175  *      trace_event_triggers.c).
1176  *
1177  * @free: An optional de-initialization function called for the
1178  *      trigger when the trigger is unregistered (via the
1179  *      event_command @reg() function).  This can be used to perform
1180  *      per-trigger de-initialization such as decrementing a
1181  *      per-trigger reference count and freeing corresponding trigger
1182  *      data, for instance.  This is usually implemented by the
1183  *      generic utility function @event_trigger_free() (see
1184  *      trace_event_triggers.c).
1185  *
1186  * @print: The callback function invoked to have the trigger print
1187  *      itself.  This is usually implemented by a wrapper function
1188  *      that calls the generic utility function @event_trigger_print()
1189  *      (see trace_event_triggers.c).
1190  */
1191 struct event_trigger_ops {
1192         void                    (*func)(struct event_trigger_data *data);
1193         int                     (*init)(struct event_trigger_ops *ops,
1194                                         struct event_trigger_data *data);
1195         void                    (*free)(struct event_trigger_ops *ops,
1196                                         struct event_trigger_data *data);
1197         int                     (*print)(struct seq_file *m,
1198                                          struct event_trigger_ops *ops,
1199                                          struct event_trigger_data *data);
1200 };
1201
1202 /**
1203  * struct event_command - callbacks and data members for event commands
1204  *
1205  * Event commands are invoked by users by writing the command name
1206  * into the 'trigger' file associated with a trace event.  The
1207  * parameters associated with a specific invocation of an event
1208  * command are used to create an event trigger instance, which is
1209  * added to the list of trigger instances associated with that trace
1210  * event.  When the event is hit, the set of triggers associated with
1211  * that event is invoked.
1212  *
1213  * The data members in this structure provide per-event command data
1214  * for various event commands.
1215  *
1216  * All the data members below, except for @post_trigger, must be set
1217  * for each event command.
1218  *
1219  * @name: The unique name that identifies the event command.  This is
1220  *      the name used when setting triggers via trigger files.
1221  *
1222  * @trigger_type: A unique id that identifies the event command
1223  *      'type'.  This value has two purposes, the first to ensure that
1224  *      only one trigger of the same type can be set at a given time
1225  *      for a particular event e.g. it doesn't make sense to have both
1226  *      a traceon and traceoff trigger attached to a single event at
1227  *      the same time, so traceon and traceoff have the same type
1228  *      though they have different names.  The @trigger_type value is
1229  *      also used as a bit value for deferring the actual trigger
1230  *      action until after the current event is finished.  Some
1231  *      commands need to do this if they themselves log to the trace
1232  *      buffer (see the @post_trigger() member below).  @trigger_type
1233  *      values are defined by adding new values to the trigger_type
1234  *      enum in include/linux/trace_events.h.
1235  *
1236  * @post_trigger: A flag that says whether or not this command needs
1237  *      to have its action delayed until after the current event has
1238  *      been closed.  Some triggers need to avoid being invoked while
1239  *      an event is currently in the process of being logged, since
1240  *      the trigger may itself log data into the trace buffer.  Thus
1241  *      we make sure the current event is committed before invoking
1242  *      those triggers.  To do that, the trigger invocation is split
1243  *      in two - the first part checks the filter using the current
1244  *      trace record; if a command has the @post_trigger flag set, it
1245  *      sets a bit for itself in the return value, otherwise it
1246  *      directly invokes the trigger.  Once all commands have been
1247  *      either invoked or set their return flag, the current record is
1248  *      either committed or discarded.  At that point, if any commands
1249  *      have deferred their triggers, those commands are finally
1250  *      invoked following the close of the current event.  In other
1251  *      words, if the event_trigger_ops @func() probe implementation
1252  *      itself logs to the trace buffer, this flag should be set,
1253  *      otherwise it can be left unspecified.
1254  *
1255  * All the methods below, except for @set_filter(), must be
1256  * implemented.
1257  *
1258  * @func: The callback function responsible for parsing and
1259  *      registering the trigger written to the 'trigger' file by the
1260  *      user.  It allocates the trigger instance and registers it with
1261  *      the appropriate trace event.  It makes use of the other
1262  *      event_command callback functions to orchestrate this, and is
1263  *      usually implemented by the generic utility function
1264  *      @event_trigger_callback() (see trace_event_triggers.c).
1265  *
1266  * @reg: Adds the trigger to the list of triggers associated with the
1267  *      event, and enables the event trigger itself, after
1268  *      initializing it (via the event_trigger_ops @init() function).
1269  *      This is also where commands can use the @trigger_type value to
1270  *      make the decision as to whether or not multiple instances of
1271  *      the trigger should be allowed.  This is usually implemented by
1272  *      the generic utility function @register_trigger() (see
1273  *      trace_event_triggers.c).
1274  *
1275  * @unreg: Removes the trigger from the list of triggers associated
1276  *      with the event, and disables the event trigger itself, after
1277  *      initializing it (via the event_trigger_ops @free() function).
1278  *      This is usually implemented by the generic utility function
1279  *      @unregister_trigger() (see trace_event_triggers.c).
1280  *
1281  * @set_filter: An optional function called to parse and set a filter
1282  *      for the trigger.  If no @set_filter() method is set for the
1283  *      event command, filters set by the user for the command will be
1284  *      ignored.  This is usually implemented by the generic utility
1285  *      function @set_trigger_filter() (see trace_event_triggers.c).
1286  *
1287  * @get_trigger_ops: The callback function invoked to retrieve the
1288  *      event_trigger_ops implementation associated with the command.
1289  */
1290 struct event_command {
1291         struct list_head        list;
1292         char                    *name;
1293         enum event_trigger_type trigger_type;
1294         bool                    post_trigger;
1295         int                     (*func)(struct event_command *cmd_ops,
1296                                         struct trace_event_file *file,
1297                                         char *glob, char *cmd, char *params);
1298         int                     (*reg)(char *glob,
1299                                        struct event_trigger_ops *ops,
1300                                        struct event_trigger_data *data,
1301                                        struct trace_event_file *file);
1302         void                    (*unreg)(char *glob,
1303                                          struct event_trigger_ops *ops,
1304                                          struct event_trigger_data *data,
1305                                          struct trace_event_file *file);
1306         int                     (*set_filter)(char *filter_str,
1307                                               struct event_trigger_data *data,
1308                                               struct trace_event_file *file);
1309         struct event_trigger_ops *(*get_trigger_ops)(char *cmd, char *param);
1310 };
1311
1312 extern int trace_event_enable_disable(struct trace_event_file *file,
1313                                       int enable, int soft_disable);
1314 extern int tracing_alloc_snapshot(void);
1315
1316 extern const char *__start___trace_bprintk_fmt[];
1317 extern const char *__stop___trace_bprintk_fmt[];
1318
1319 extern const char *__start___tracepoint_str[];
1320 extern const char *__stop___tracepoint_str[];
1321
1322 void trace_printk_control(bool enabled);
1323 void trace_printk_init_buffers(void);
1324 void trace_printk_start_comm(void);
1325 int trace_keep_overwrite(struct tracer *tracer, u32 mask, int set);
1326 int set_tracer_flag(struct trace_array *tr, unsigned int mask, int enabled);
1327
1328 /*
1329  * Normal trace_printk() and friends allocates special buffers
1330  * to do the manipulation, as well as saves the print formats
1331  * into sections to display. But the trace infrastructure wants
1332  * to use these without the added overhead at the price of being
1333  * a bit slower (used mainly for warnings, where we don't care
1334  * about performance). The internal_trace_puts() is for such
1335  * a purpose.
1336  */
1337 #define internal_trace_puts(str) __trace_puts(_THIS_IP_, str, strlen(str))
1338
1339 #undef FTRACE_ENTRY
1340 #define FTRACE_ENTRY(call, struct_name, id, tstruct, print, filter)     \
1341         extern struct trace_event_call                                  \
1342         __aligned(4) event_##call;
1343 #undef FTRACE_ENTRY_DUP
1344 #define FTRACE_ENTRY_DUP(call, struct_name, id, tstruct, print, filter) \
1345         FTRACE_ENTRY(call, struct_name, id, PARAMS(tstruct), PARAMS(print), \
1346                      filter)
1347 #include "trace_entries.h"
1348
1349 #if defined(CONFIG_PERF_EVENTS) && defined(CONFIG_FUNCTION_TRACER)
1350 int perf_ftrace_event_register(struct trace_event_call *call,
1351                                enum trace_reg type, void *data);
1352 #else
1353 #define perf_ftrace_event_register NULL
1354 #endif
1355
1356 #ifdef CONFIG_FTRACE_SYSCALLS
1357 void init_ftrace_syscalls(void);
1358 #else
1359 static inline void init_ftrace_syscalls(void) { }
1360 #endif
1361
1362 #ifdef CONFIG_EVENT_TRACING
1363 void trace_event_init(void);
1364 void trace_event_enum_update(struct trace_enum_map **map, int len);
1365 #else
1366 static inline void __init trace_event_init(void) { }
1367 static inline void trace_event_enum_update(struct trace_enum_map **map, int len) { }
1368 #endif
1369
1370 extern struct trace_iterator *tracepoint_print_iter;
1371
1372 #endif /* _LINUX_KERNEL_TRACE_H */