tracing: Add and use generic set_trigger_filter() implementation

Add a generic event_command.set_trigger_filter() op implementation and
have the current set of trigger commands use it - this essentially
gives them all support for filters.

Syntactically, filters are supported by adding 'if <filter>' just
after the command, in which case only events matching the filter will
invoke the trigger.  For example, to add a filter to an
enable/disable_event command:

    echo 'enable_event:system:event if common_pid == 999' > \
              .../othersys/otherevent/trigger

The above command will only enable the system:event event if the
common_pid field in the othersys:otherevent event is 999.

As another example, to add a filter to a stacktrace command:

    echo 'stacktrace if common_pid == 999' > \
                   .../somesys/someevent/trigger

The above command will only trigger a stacktrace if the common_pid
field in the event is 999.

The filter syntax is the same as that described in the 'Event
filtering' section of Documentation/trace/events.txt.

Because triggers can now use filters, the trigger-invoking logic needs
to be moved in those cases - e.g. for ftrace_raw_event_calls, if a
trigger has a filter associated with it, the trigger invocation now
needs to happen after the { assign; } part of the call, in order for
the trigger condition to be tested.

There's still a SOFT_DISABLED-only check at the top of e.g. the
ftrace_raw_events function, so when an event is soft disabled but not
because of the presence of a trigger, the original SOFT_DISABLED
behavior remains unchanged.

There's also a bit of trickiness in that 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, we split the trigger invocation in two - the
first part (event_triggers_call()) 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 invoks the
trigger.  Once all commands have been either invoked or set their
return flag, event_triggers_call() returns.  The current record is
then either committed or discarded; if any commands have deferred
their triggers, those commands are finally invoked following the close
of the current event by event_triggers_post_call().

To simplify the above and make it more efficient, the TRIGGER_COND bit
is introduced, which is set only if a soft-disabled trigger needs to
use the log record for filter testing or needs to wait until the
current log record is closed.

The syscall event invocation code is also changed in analogous ways.

Because event triggers need to be able to create and free filters,
this also adds a couple external wrappers for the existing
create_filter and free_filter functions, which are too generic to be
made extern functions themselves.

Link: http://lkml.kernel.org/r/7164930759d8719ef460357f143d995406e4eead.1382622043.git.tom.zanussi@linux.intel.com

Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>

1 files changed, 36 insertions, 12 deletions

diff --git a/include/trace/ftrace.h b/include/trace/ftrace.h
index 0a48bff964bd..0962968b8b37 100644
--- a/include/trace/ftrace.h
+++ b/include/trace/ftrace.h
@@ -418,6 +418,8 @@ static inline notrace int ftrace_get_offsets_##call(			\
  *      struct ftrace_event_file *ftrace_file = __data;
  *      struct ftrace_event_call *event_call = ftrace_file->event_call;
  *      struct ftrace_data_offsets_<call> __maybe_unused __data_offsets;
+ *      unsigned long eflags = ftrace_file->flags;
+ *      enum event_trigger_type __tt = ETT_NONE;
  *      struct ring_buffer_event *event;
  *      struct ftrace_raw_<call> *entry; <-- defined in stage 1
  *      struct ring_buffer *buffer;
@@ -425,9 +427,12 @@ static inline notrace int ftrace_get_offsets_##call(			\
  *      int __data_size;
  *      int pc;
  *
- *      if (test_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT,
- *                   &ftrace_file->flags))
- *              return;
+ *      if (!(eflags & FTRACE_EVENT_FL_TRIGGER_COND)) {
+ *              if (eflags & FTRACE_EVENT_FL_TRIGGER_MODE)
+ *                      event_triggers_call(ftrace_file, NULL);
+ *              if (eflags & FTRACE_EVENT_FL_SOFT_DISABLED)
+ *                      return;
+ *      }
  *
  *      local_save_flags(irq_flags);
  *      pc = preempt_count();
@@ -445,8 +450,17 @@ static inline notrace int ftrace_get_offsets_##call(			\
  *      { <assign>; }  <-- Here we assign the entries by the __field and
  *                         __array macros.
  *
- *      if (!filter_check_discard(ftrace_file, entry, buffer, event))
+ *      if (eflags & FTRACE_EVENT_FL_TRIGGER_COND)
+ *              __tt = event_triggers_call(ftrace_file, entry);
+ *
+ *      if (test_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT,
+ *                   &ftrace_file->flags))
+ *              ring_buffer_discard_commit(buffer, event);
+ *      else if (!filter_check_discard(ftrace_file, entry, buffer, event))
  *              trace_buffer_unlock_commit(buffer, event, irq_flags, pc);
+ *
+ *      if (__tt)
+ *              event_triggers_post_call(ftrace_file, __tt);
  * }
  *
  * static struct trace_event ftrace_event_type_<call> = {
@@ -532,6 +546,8 @@ ftrace_raw_event_##call(void *__data, proto)				\
         struct ftrace_event_file *ftrace_file = __data;                 \
         struct ftrace_event_call *event_call = ftrace_file->event_call; \
         struct ftrace_data_offsets_##call __maybe_unused __data_offsets;\
+        unsigned long eflags = ftrace_file->flags;                      \
+        enum event_trigger_type __tt = ETT_NONE;                        \
         struct ring_buffer_event *event;                                \
         struct ftrace_raw_##call *entry;                                \
         struct ring_buffer *buffer;                                     \
@@ -539,13 +555,12 @@ ftrace_raw_event_##call(void *__data, proto)				\
         int __data_size;                                                \
         int pc;                                                         \
                                                                         \
-        if (test_bit(FTRACE_EVENT_FL_TRIGGER_MODE_BIT,                  \
-                     &ftrace_file->flags))                              \
-                event_triggers_call(ftrace_file);                       \
-                                                                        \
-        if (test_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT,                 \
-                     &ftrace_file->flags))                              \
-                return;                                                 \
+        if (!(eflags & FTRACE_EVENT_FL_TRIGGER_COND)) {                 \
+                if (eflags & FTRACE_EVENT_FL_TRIGGER_MODE)              \
+                        event_triggers_call(ftrace_file, NULL);         \
+                if (eflags & FTRACE_EVENT_FL_SOFT_DISABLED)             \
+                        return;                                         \
+        }                                                               \
                                                                         \
         local_save_flags(irq_flags);                                    \
         pc = preempt_count();                                           \
@@ -564,8 +579,17 @@ ftrace_raw_event_##call(void *__data, proto)				\
                                                                         \
         { assign; }                                                     \
                                                                         \
-        if (!filter_check_discard(ftrace_file, entry, buffer, event))   \
+        if (eflags & FTRACE_EVENT_FL_TRIGGER_COND)                      \
+                __tt = event_triggers_call(ftrace_file, entry);         \
+                                                                        \
+        if (test_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT,                 \
+                     &ftrace_file->flags))                              \
+                ring_buffer_discard_commit(buffer, event);              \
+        else if (!filter_check_discard(ftrace_file, entry, buffer, event)) \
                 trace_buffer_unlock_commit(buffer, event, irq_flags, pc); \
+                                                                        \
+        if (__tt)                                                       \
+                event_triggers_post_call(ftrace_file, __tt);            \
 }
 /*
  * The ftrace_test_probe is compiled out, it is only here as a build time check