1 files changed, 193 insertions, 0 deletions

diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
index ea189e027b80..02b592f2d4b7 100644
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -1,3 +1,4 @@
+
 #ifndef _LINUX_KERNEL_TRACE_H
 #define _LINUX_KERNEL_TRACE_H
 
@@ -587,6 +588,8 @@ void tracing_start_sched_switch_record(void);
 int register_tracer(struct tracer *type);
 int is_tracing_stopped(void);
 
+loff_t tracing_lseek(struct file *file, loff_t offset, int whence);
+
 extern cpumask_var_t __read_mostly tracing_buffer_mask;
 
 #define for_each_tracing_cpu(cpu)       \
@@ -1020,6 +1023,10 @@ extern int apply_subsystem_event_filter(struct ftrace_subsystem_dir *dir,
 extern void print_subsystem_event_filter(struct event_subsystem *system,
                                          struct trace_seq *s);
 extern int filter_assign_type(const char *type);
+extern int create_event_filter(struct ftrace_event_call *call,
+                               char *filter_str, bool set_str,
+                               struct event_filter **filterp);
+extern void free_event_filter(struct event_filter *filter);
 
 struct ftrace_event_field *
 trace_find_event_field(struct ftrace_event_call *call, char *name);
@@ -1028,9 +1035,195 @@ extern void trace_event_enable_cmd_record(bool enable);
 extern int event_trace_add_tracer(struct dentry *parent, struct trace_array *tr);
 extern int event_trace_del_tracer(struct trace_array *tr);
 
+extern struct ftrace_event_file *find_event_file(struct trace_array *tr,
+                                                 const char *system,
+                                                 const char *event);
+
+static inline void *event_file_data(struct file *filp)
+{
+        return ACCESS_ONCE(file_inode(filp)->i_private);
+}
+
 extern struct mutex event_mutex;
 extern struct list_head ftrace_events;
 
+extern const struct file_operations event_trigger_fops;
+
+extern int register_trigger_cmds(void);
+extern void clear_event_triggers(struct trace_array *tr);
+
+struct event_trigger_data {
+        unsigned long                   count;
+        int                             ref;
+        struct event_trigger_ops        *ops;
+        struct event_command            *cmd_ops;
+        struct event_filter __rcu       *filter;
+        char                            *filter_str;
+        void                            *private_data;
+        struct list_head                list;
+};
+
+/**
+ * struct event_trigger_ops - callbacks for trace event triggers
+ *
+ * The methods in this structure provide per-event trigger hooks for
+ * various trigger operations.
+ *
+ * All the methods below, except for @init() and @free(), must be
+ * implemented.
+ *
+ * @func: The trigger 'probe' function called when the triggering
+ *      event occurs.  The data passed into this callback is the data
+ *      that was supplied to the event_command @reg() function that
+ *      registered the trigger (see struct event_command).
+ *
+ * @init: An optional initialization function called for the trigger
+ *      when the trigger is registered (via the event_command reg()
+ *      function).  This can be used to perform per-trigger
+ *      initialization such as incrementing a per-trigger reference
+ *      count, for instance.  This is usually implemented by the
+ *      generic utility function @event_trigger_init() (see
+ *      trace_event_triggers.c).
+ *
+ * @free: An optional de-initialization function called for the
+ *      trigger when the trigger is unregistered (via the
+ *      event_command @reg() function).  This can be used to perform
+ *      per-trigger de-initialization such as decrementing a
+ *      per-trigger reference count and freeing corresponding trigger
+ *      data, for instance.  This is usually implemented by the
+ *      generic utility function @event_trigger_free() (see
+ *      trace_event_triggers.c).
+ *
+ * @print: The callback function invoked to have the trigger print
+ *      itself.  This is usually implemented by a wrapper function
+ *      that calls the generic utility function @event_trigger_print()
+ *      (see trace_event_triggers.c).
+ */
+struct event_trigger_ops {
+        void                    (*func)(struct event_trigger_data *data);
+        int                     (*init)(struct event_trigger_ops *ops,
+                                        struct event_trigger_data *data);
+        void                    (*free)(struct event_trigger_ops *ops,
+                                        struct event_trigger_data *data);
+        int                     (*print)(struct seq_file *m,
+                                         struct event_trigger_ops *ops,
+                                         struct event_trigger_data *data);
+};
+
+/**
+ * struct event_command - callbacks and data members for event commands
+ *
+ * Event commands are invoked by users by writing the command name
+ * into the 'trigger' file associated with a trace event.  The
+ * parameters associated with a specific invocation of an event
+ * command are used to create an event trigger instance, which is
+ * added to the list of trigger instances associated with that trace
+ * event.  When the event is hit, the set of triggers associated with
+ * that event is invoked.
+ *
+ * The data members in this structure provide per-event command data
+ * for various event commands.
+ *
+ * All the data members below, except for @post_trigger, must be set
+ * for each event command.
+ *
+ * @name: The unique name that identifies the event command.  This is
+ *      the name used when setting triggers via trigger files.
+ *
+ * @trigger_type: A unique id that identifies the event command
+ *      'type'.  This value has two purposes, the first to ensure that
+ *      only one trigger of the same type can be set at a given time
+ *      for a particular event e.g. it doesn't make sense to have both
+ *      a traceon and traceoff trigger attached to a single event at
+ *      the same time, so traceon and traceoff have the same type
+ *      though they have different names.  The @trigger_type value is
+ *      also used as a bit value for deferring the actual trigger
+ *      action until after the current event is finished.  Some
+ *      commands need to do this if they themselves log to the trace
+ *      buffer (see the @post_trigger() member below).  @trigger_type
+ *      values are defined by adding new values to the trigger_type
+ *      enum in include/linux/ftrace_event.h.
+ *
+ * @post_trigger: A flag that says whether or not this command needs
+ *      to have its action delayed until after the current event has
+ *      been closed.  Some triggers need to avoid being invoked while
+ *      an event is currently in the process of being logged, since
+ *      the trigger may itself log data into the trace buffer.  Thus
+ *      we make sure the current event is committed before invoking
+ *      those triggers.  To do that, the trigger invocation is split
+ *      in two - the first part checks the filter using the current
+ *      trace record; if a command has the @post_trigger flag set, it
+ *      sets a bit for itself in the return value, otherwise it
+ *      directly invokes the trigger.  Once all commands have been
+ *      either invoked or set their return flag, the current record is
+ *      either committed or discarded.  At that point, if any commands
+ *      have deferred their triggers, those commands are finally
+ *      invoked following the close of the current event.  In other
+ *      words, if the event_trigger_ops @func() probe implementation
+ *      itself logs to the trace buffer, this flag should be set,
+ *      otherwise it can be left unspecified.
+ *
+ * All the methods below, except for @set_filter(), must be
+ * implemented.
+ *
+ * @func: The callback function responsible for parsing and
+ *      registering the trigger written to the 'trigger' file by the
+ *      user.  It allocates the trigger instance and registers it with
+ *      the appropriate trace event.  It makes use of the other
+ *      event_command callback functions to orchestrate this, and is
+ *      usually implemented by the generic utility function
+ *      @event_trigger_callback() (see trace_event_triggers.c).
+ *
+ * @reg: Adds the trigger to the list of triggers associated with the
+ *      event, and enables the event trigger itself, after
+ *      initializing it (via the event_trigger_ops @init() function).
+ *      This is also where commands can use the @trigger_type value to
+ *      make the decision as to whether or not multiple instances of
+ *      the trigger should be allowed.  This is usually implemented by
+ *      the generic utility function @register_trigger() (see
+ *      trace_event_triggers.c).
+ *
+ * @unreg: Removes the trigger from the list of triggers associated
+ *      with the event, and disables the event trigger itself, after
+ *      initializing it (via the event_trigger_ops @free() function).
+ *      This is usually implemented by the generic utility function
+ *      @unregister_trigger() (see trace_event_triggers.c).
+ *
+ * @set_filter: An optional function called to parse and set a filter
+ *      for the trigger.  If no @set_filter() method is set for the
+ *      event command, filters set by the user for the command will be
+ *      ignored.  This is usually implemented by the generic utility
+ *      function @set_trigger_filter() (see trace_event_triggers.c).
+ *
+ * @get_trigger_ops: The callback function invoked to retrieve the
+ *      event_trigger_ops implementation associated with the command.
+ */
+struct event_command {
+        struct list_head        list;
+        char                    *name;
+        enum event_trigger_type trigger_type;
+        bool                    post_trigger;
+        int                     (*func)(struct event_command *cmd_ops,
+                                        struct ftrace_event_file *file,
+                                        char *glob, char *cmd, char *params);
+        int                     (*reg)(char *glob,
+                                       struct event_trigger_ops *ops,
+                                       struct event_trigger_data *data,
+                                       struct ftrace_event_file *file);
+        void                    (*unreg)(char *glob,
+                                         struct event_trigger_ops *ops,
+                                         struct event_trigger_data *data,
+                                         struct ftrace_event_file *file);
+        int                     (*set_filter)(char *filter_str,
+                                              struct event_trigger_data *data,
+                                              struct ftrace_event_file *file);
+        struct event_trigger_ops *(*get_trigger_ops)(char *cmd, char *param);
+};
+
+extern int trace_event_enable_disable(struct ftrace_event_file *file,
+                                      int enable, int soft_disable);
+extern int tracing_alloc_snapshot(void);
+
 extern const char *__start___trace_bprintk_fmt[];
 extern const char *__stop___trace_bprintk_fmt[];