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>
2013-10-24 20:59:29 +07:00
|
|
|
|
2008-05-13 02:20:42 +07:00
|
|
|
#ifndef _LINUX_KERNEL_TRACE_H
|
|
|
|
#define _LINUX_KERNEL_TRACE_H
|
|
|
|
|
|
|
|
#include <linux/fs.h>
|
2011-07-27 06:09:06 +07:00
|
|
|
#include <linux/atomic.h>
|
2008-05-13 02:20:42 +07:00
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/clocksource.h>
|
2008-09-30 10:02:41 +07:00
|
|
|
#include <linux/ring_buffer.h>
|
ftrace: mmiotrace, updates
here is a patch that makes mmiotrace work almost well within the tracing
framework. The patch applies on top of my previous patch. I have my own
output formatting in place now.
Summary of changes:
- fix the NULL dereference that was due to not calling tracing_reset()
- add print_line() callback into struct tracer
- implement print_line() for mmiotrace, producing up-to-spec text
- add my output header, but that is not really called in the right place
- rewrote the main structs in mmiotrace
- added two new trace entry types: TRACE_MMIO_RW and TRACE_MMIO_MAP
- made some functions in trace.c non-static
- check current==NULL in tracing_generic_entry_update()
- fix(?) comparison in trace_seq_printf()
Things seem to work fine except a few issues. Markers (text lines injected
into mmiotrace log) are missing, I did not feel hacking them in before we
have variable length entries. My output header is printed only for 'trace'
file, but not 'trace_pipe'. For some reason, despite my quick fix,
iter->trace is NULL in print_trace_line() when called from 'trace_pipe'
file, which means I don't get proper output formatting.
I only tried by loading nouveau.ko, which just detects the card, and that
is traced fine. I didn't try further. Map, two reads and unmap. Works
perfectly.
I am missing the information about overflows, I'd prefer to have a
counter for lost events. I didn't try, but I guess currently there is no
way of knowning when it overflows?
So, not too far from being fully operational, it seems :-)
And looking at the diffstat, there also is some 700-900 lines of user space
code that just became obsolete.
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-13 02:20:57 +07:00
|
|
|
#include <linux/mmiotrace.h>
|
2009-09-13 06:26:21 +07:00
|
|
|
#include <linux/tracepoint.h>
|
2008-09-23 17:32:08 +07:00
|
|
|
#include <linux/ftrace.h>
|
2009-09-10 00:22:48 +07:00
|
|
|
#include <linux/hw_breakpoint.h>
|
tracing: make trace_seq operations available for core kernel
In the process to make TRACE_EVENT macro work for modules, the trace_seq
operations must be available for core kernel code.
These operations are quite useful and can be used for other implementations.
The main idea is that we create a trace_seq handle that acts very much
like the seq_file handle.
struct trace_seq *s = kmalloc(sizeof(*s, GFP_KERNEL);
trace_seq_init(s);
trace_seq_printf(s, "some data %d\n", variable);
printk("%s", s->buffer);
The main use is to allow a top level function call several other functions
that may store printf like data into the buffer. Then at the end, the top
level function can process all the data with any method it would like to.
It could be passed to userspace, output via printk or even use seq_file:
trace_seq_to_user(s, ubuf, cnt);
seq_puts(m, s->buffer);
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2009-04-11 23:59:57 +07:00
|
|
|
#include <linux/trace_seq.h>
|
2015-04-30 01:36:05 +07:00
|
|
|
#include <linux/trace_events.h>
|
2014-04-08 05:39:20 +07:00
|
|
|
#include <linux/compiler.h>
|
2014-11-12 22:29:54 +07:00
|
|
|
#include <linux/trace_seq.h>
|
2016-10-05 18:58:15 +07:00
|
|
|
#include <linux/glob.h>
|
tracing: make trace_seq operations available for core kernel
In the process to make TRACE_EVENT macro work for modules, the trace_seq
operations must be available for core kernel code.
These operations are quite useful and can be used for other implementations.
The main idea is that we create a trace_seq handle that acts very much
like the seq_file handle.
struct trace_seq *s = kmalloc(sizeof(*s, GFP_KERNEL);
trace_seq_init(s);
trace_seq_printf(s, "some data %d\n", variable);
printk("%s", s->buffer);
The main use is to allow a top level function call several other functions
that may store printf like data into the buffer. Then at the end, the top
level function can process all the data with any method it would like to.
It could be passed to userspace, output via printk or even use seq_file:
trace_seq_to_user(s, ubuf, cnt);
seq_puts(m, s->buffer);
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2009-04-11 23:59:57 +07:00
|
|
|
|
2012-08-09 01:48:20 +07:00
|
|
|
#ifdef CONFIG_FTRACE_SYSCALLS
|
|
|
|
#include <asm/unistd.h> /* For NR_SYSCALLS */
|
|
|
|
#include <asm/syscall.h> /* some archs define it here */
|
|
|
|
#endif
|
|
|
|
|
2008-05-24 02:37:28 +07:00
|
|
|
enum trace_type {
|
|
|
|
__TRACE_FIRST_TYPE = 0,
|
|
|
|
|
|
|
|
TRACE_FN,
|
|
|
|
TRACE_CTX,
|
|
|
|
TRACE_WAKE,
|
|
|
|
TRACE_STACK,
|
2008-08-01 23:26:41 +07:00
|
|
|
TRACE_PRINT,
|
2009-03-13 00:24:49 +07:00
|
|
|
TRACE_BPRINT,
|
ftrace: mmiotrace, updates
here is a patch that makes mmiotrace work almost well within the tracing
framework. The patch applies on top of my previous patch. I have my own
output formatting in place now.
Summary of changes:
- fix the NULL dereference that was due to not calling tracing_reset()
- add print_line() callback into struct tracer
- implement print_line() for mmiotrace, producing up-to-spec text
- add my output header, but that is not really called in the right place
- rewrote the main structs in mmiotrace
- added two new trace entry types: TRACE_MMIO_RW and TRACE_MMIO_MAP
- made some functions in trace.c non-static
- check current==NULL in tracing_generic_entry_update()
- fix(?) comparison in trace_seq_printf()
Things seem to work fine except a few issues. Markers (text lines injected
into mmiotrace log) are missing, I did not feel hacking them in before we
have variable length entries. My output header is printed only for 'trace'
file, but not 'trace_pipe'. For some reason, despite my quick fix,
iter->trace is NULL in print_trace_line() when called from 'trace_pipe'
file, which means I don't get proper output formatting.
I only tried by loading nouveau.ko, which just detects the card, and that
is traced fine. I didn't try further. Map, two reads and unmap. Works
perfectly.
I am missing the information about overflows, I'd prefer to have a
counter for lost events. I didn't try, but I guess currently there is no
way of knowning when it overflows?
So, not too far from being fully operational, it seems :-)
And looking at the diffstat, there also is some 700-900 lines of user space
code that just became obsolete.
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-13 02:20:57 +07:00
|
|
|
TRACE_MMIO_RW,
|
|
|
|
TRACE_MMIO_MAP,
|
2008-11-13 03:24:24 +07:00
|
|
|
TRACE_BRANCH,
|
2008-11-26 06:57:25 +07:00
|
|
|
TRACE_GRAPH_RET,
|
|
|
|
TRACE_GRAPH_ENT,
|
2008-11-22 18:28:47 +07:00
|
|
|
TRACE_USER_STACK,
|
blktrace: add ftrace plugin
Impact: New way of using the blktrace infrastructure
This drops the requirement of userspace utilities to use the blktrace
facility.
Configuration is done thru sysfs, adding a "trace" directory to the
partition directory where blktrace can be enabled for the associated
request_queue.
The same filters present in the IOCTL interface are present as sysfs
device attributes.
The /sys/block/sdX/sdXN/trace/enable file allows tracing without any
filters.
The other files in this directory: pid, act_mask, start_lba and end_lba
can be used with the same meaning as with the IOCTL interface.
Using the sysfs interface will only setup the request_queue->blk_trace
fields, tracing will only take place when the "blk" tracer is selected
via the ftrace interface, as in the following example:
To see the trace, one can use the /d/tracing/trace file or the
/d/tracign/trace_pipe file, with semantics defined in the ftrace
documentation in Documentation/ftrace.txt.
[root@f10-1 ~]# cat /t/trace
kjournald-305 [000] 3046.491224: 8,1 A WBS 6367 + 8 <- (8,1) 6304
kjournald-305 [000] 3046.491227: 8,1 Q R 6367 + 8 [kjournald]
kjournald-305 [000] 3046.491236: 8,1 G RB 6367 + 8 [kjournald]
kjournald-305 [000] 3046.491239: 8,1 P NS [kjournald]
kjournald-305 [000] 3046.491242: 8,1 I RBS 6367 + 8 [kjournald]
kjournald-305 [000] 3046.491251: 8,1 D WB 6367 + 8 [kjournald]
kjournald-305 [000] 3046.491610: 8,1 U WS [kjournald] 1
<idle>-0 [000] 3046.511914: 8,1 C RS 6367 + 8 [6367]
[root@f10-1 ~]#
The default line context (prefix) format is the one described in the ftrace
documentation, with the blktrace specific bits using its existing format,
described in blkparse(8).
If one wants to have the classic blktrace formatting, this is possible by
using:
[root@f10-1 ~]# echo blk_classic > /t/trace_options
[root@f10-1 ~]# cat /t/trace
8,1 0 3046.491224 305 A WBS 6367 + 8 <- (8,1) 6304
8,1 0 3046.491227 305 Q R 6367 + 8 [kjournald]
8,1 0 3046.491236 305 G RB 6367 + 8 [kjournald]
8,1 0 3046.491239 305 P NS [kjournald]
8,1 0 3046.491242 305 I RBS 6367 + 8 [kjournald]
8,1 0 3046.491251 305 D WB 6367 + 8 [kjournald]
8,1 0 3046.491610 305 U WS [kjournald] 1
8,1 0 3046.511914 0 C RS 6367 + 8 [6367]
[root@f10-1 ~]#
Using the ftrace standard format allows more flexibility, such
as the ability of asking for backtraces via trace_options:
[root@f10-1 ~]# echo noblk_classic > /t/trace_options
[root@f10-1 ~]# echo stacktrace > /t/trace_options
[root@f10-1 ~]# cat /t/trace
kjournald-305 [000] 3318.826779: 8,1 A WBS 6375 + 8 <- (8,1) 6312
kjournald-305 [000] 3318.826782:
<= submit_bio
<= submit_bh
<= sync_dirty_buffer
<= journal_commit_transaction
<= kjournald
<= kthread
<= child_rip
kjournald-305 [000] 3318.826836: 8,1 Q R 6375 + 8 [kjournald]
kjournald-305 [000] 3318.826837:
<= generic_make_request
<= submit_bio
<= submit_bh
<= sync_dirty_buffer
<= journal_commit_transaction
<= kjournald
<= kthread
Please read the ftrace documentation to use aditional, standardized
tracing filters such as /d/tracing/trace_cpumask, etc.
See also /d/tracing/trace_mark to add comments in the trace stream,
that is equivalent to the /d/block/sdaN/msg interface.
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-01-23 21:06:27 +07:00
|
|
|
TRACE_BLK,
|
2013-03-09 09:02:34 +07:00
|
|
|
TRACE_BPUTS,
|
2016-06-23 23:45:36 +07:00
|
|
|
TRACE_HWLAT,
|
2016-07-07 02:25:08 +07:00
|
|
|
TRACE_RAW_DATA,
|
2008-05-24 02:37:28 +07:00
|
|
|
|
2008-12-24 11:24:12 +07:00
|
|
|
__TRACE_LAST_TYPE,
|
2008-05-24 02:37:28 +07:00
|
|
|
};
|
|
|
|
|
2008-05-13 02:20:42 +07:00
|
|
|
|
2009-09-13 06:17:15 +07:00
|
|
|
#undef __field
|
|
|
|
#define __field(type, item) type item;
|
2008-05-13 02:20:51 +07:00
|
|
|
|
2009-09-13 06:22:23 +07:00
|
|
|
#undef __field_struct
|
|
|
|
#define __field_struct(type, item) __field(type, item)
|
2008-05-13 02:20:51 +07:00
|
|
|
|
2009-09-13 06:22:23 +07:00
|
|
|
#undef __field_desc
|
|
|
|
#define __field_desc(type, container, item)
|
2008-11-22 18:28:47 +07:00
|
|
|
|
2009-09-13 06:17:15 +07:00
|
|
|
#undef __array
|
|
|
|
#define __array(type, item, size) type item[size];
|
2009-03-06 23:21:47 +07:00
|
|
|
|
2009-09-13 06:22:23 +07:00
|
|
|
#undef __array_desc
|
|
|
|
#define __array_desc(type, container, item, size)
|
2008-09-30 10:02:42 +07:00
|
|
|
|
2009-09-13 06:17:15 +07:00
|
|
|
#undef __dynamic_array
|
|
|
|
#define __dynamic_array(type, item) type item[];
|
2008-09-30 10:02:42 +07:00
|
|
|
|
2009-09-13 06:17:15 +07:00
|
|
|
#undef F_STRUCT
|
|
|
|
#define F_STRUCT(args...) args
|
2008-11-12 05:24:42 +07:00
|
|
|
|
2009-09-13 06:17:15 +07:00
|
|
|
#undef FTRACE_ENTRY
|
2012-02-15 21:51:53 +07:00
|
|
|
#define FTRACE_ENTRY(name, struct_name, id, tstruct, print, filter) \
|
|
|
|
struct struct_name { \
|
|
|
|
struct trace_entry ent; \
|
|
|
|
tstruct \
|
2009-09-13 06:17:15 +07:00
|
|
|
}
|
2008-09-30 10:02:42 +07:00
|
|
|
|
2009-09-13 06:17:15 +07:00
|
|
|
#undef FTRACE_ENTRY_DUP
|
2012-02-15 21:51:53 +07:00
|
|
|
#define FTRACE_ENTRY_DUP(name, name_struct, id, tstruct, printk, filter)
|
2008-11-25 15:24:15 +07:00
|
|
|
|
2012-02-15 21:51:51 +07:00
|
|
|
#undef FTRACE_ENTRY_REG
|
2012-02-15 21:51:53 +07:00
|
|
|
#define FTRACE_ENTRY_REG(name, struct_name, id, tstruct, print, \
|
|
|
|
filter, regfn) \
|
|
|
|
FTRACE_ENTRY(name, struct_name, id, PARAMS(tstruct), PARAMS(print), \
|
|
|
|
filter)
|
2012-02-15 21:51:51 +07:00
|
|
|
|
2016-06-29 17:56:48 +07:00
|
|
|
#undef FTRACE_ENTRY_PACKED
|
|
|
|
#define FTRACE_ENTRY_PACKED(name, struct_name, id, tstruct, print, \
|
|
|
|
filter) \
|
|
|
|
FTRACE_ENTRY(name, struct_name, id, PARAMS(tstruct), PARAMS(print), \
|
|
|
|
filter) __packed
|
|
|
|
|
2009-09-13 06:17:15 +07:00
|
|
|
#include "trace_entries.h"
|
2008-12-30 04:42:23 +07:00
|
|
|
|
2009-09-13 06:17:15 +07:00
|
|
|
/*
|
|
|
|
* syscalls are special, and need special handling, this is why
|
|
|
|
* they are not included in trace_entries.h
|
|
|
|
*/
|
2009-03-13 21:42:11 +07:00
|
|
|
struct syscall_trace_enter {
|
|
|
|
struct trace_entry ent;
|
|
|
|
int nr;
|
|
|
|
unsigned long args[];
|
|
|
|
};
|
|
|
|
|
|
|
|
struct syscall_trace_exit {
|
|
|
|
struct trace_entry ent;
|
|
|
|
int nr;
|
2009-11-25 14:14:59 +07:00
|
|
|
long ret;
|
2009-03-13 21:42:11 +07:00
|
|
|
};
|
|
|
|
|
tracing/kprobes: Support basic types on dynamic events
Support basic types of integer (u8, u16, u32, u64, s8, s16, s32, s64) in
kprobe tracer. With this patch, users can specify above basic types on
each arguments after ':'. If omitted, the argument type is set as
unsigned long (u32 or u64, arch-dependent).
e.g.
echo 'p account_system_time+0 hardirq_offset=%si:s32' > kprobe_events
adds a probe recording hardirq_offset in signed-32bits value on the
entry of account_system_time.
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
LKML-Reference: <20100412171708.3790.18599.stgit@localhost6.localdomain6>
Signed-off-by: Masami Hiramatsu <mhiramat@redhat.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-04-13 00:17:08 +07:00
|
|
|
struct kprobe_trace_entry_head {
|
2009-08-14 03:35:11 +07:00
|
|
|
struct trace_entry ent;
|
|
|
|
unsigned long ip;
|
|
|
|
};
|
|
|
|
|
tracing/kprobes: Support basic types on dynamic events
Support basic types of integer (u8, u16, u32, u64, s8, s16, s32, s64) in
kprobe tracer. With this patch, users can specify above basic types on
each arguments after ':'. If omitted, the argument type is set as
unsigned long (u32 or u64, arch-dependent).
e.g.
echo 'p account_system_time+0 hardirq_offset=%si:s32' > kprobe_events
adds a probe recording hardirq_offset in signed-32bits value on the
entry of account_system_time.
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
LKML-Reference: <20100412171708.3790.18599.stgit@localhost6.localdomain6>
Signed-off-by: Masami Hiramatsu <mhiramat@redhat.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-04-13 00:17:08 +07:00
|
|
|
struct kretprobe_trace_entry_head {
|
2009-08-14 03:35:11 +07:00
|
|
|
struct trace_entry ent;
|
|
|
|
unsigned long func;
|
|
|
|
unsigned long ret_ip;
|
|
|
|
};
|
|
|
|
|
2008-09-17 02:02:27 +07:00
|
|
|
/*
|
|
|
|
* trace_flag_type is an enumeration that holds different
|
|
|
|
* states when a trace occurs. These are:
|
2008-10-24 20:42:59 +07:00
|
|
|
* IRQS_OFF - interrupts were disabled
|
2009-03-06 23:52:03 +07:00
|
|
|
* IRQS_NOSUPPORT - arch does not support irqs_disabled_flags
|
2009-09-10 08:34:19 +07:00
|
|
|
* NEED_RESCHED - reschedule is requested
|
2008-10-24 20:42:59 +07:00
|
|
|
* HARDIRQ - inside an interrupt handler
|
|
|
|
* SOFTIRQ - inside a softirq handler
|
2008-09-17 02:02:27 +07:00
|
|
|
*/
|
|
|
|
enum trace_flag_type {
|
|
|
|
TRACE_FLAG_IRQS_OFF = 0x01,
|
2008-10-24 20:42:59 +07:00
|
|
|
TRACE_FLAG_IRQS_NOSUPPORT = 0x02,
|
|
|
|
TRACE_FLAG_NEED_RESCHED = 0x04,
|
|
|
|
TRACE_FLAG_HARDIRQ = 0x08,
|
|
|
|
TRACE_FLAG_SOFTIRQ = 0x10,
|
2013-10-04 22:28:26 +07:00
|
|
|
TRACE_FLAG_PREEMPT_RESCHED = 0x20,
|
2016-03-18 22:28:04 +07:00
|
|
|
TRACE_FLAG_NMI = 0x40,
|
2008-09-17 02:02:27 +07:00
|
|
|
};
|
|
|
|
|
2008-09-17 02:06:42 +07:00
|
|
|
#define TRACE_BUF_SIZE 1024
|
2008-05-13 02:20:42 +07:00
|
|
|
|
2012-05-12 00:29:49 +07:00
|
|
|
struct trace_array;
|
|
|
|
|
2008-05-13 02:20:42 +07:00
|
|
|
/*
|
|
|
|
* The CPU trace array - it consists of thousands of trace entries
|
|
|
|
* plus some other descriptor data: (for example which task started
|
|
|
|
* the trace, etc.)
|
|
|
|
*/
|
|
|
|
struct trace_array_cpu {
|
|
|
|
atomic_t disabled;
|
2008-12-02 10:20:19 +07:00
|
|
|
void *buffer_page; /* ring buffer spare */
|
2008-05-13 02:20:45 +07:00
|
|
|
|
2012-02-03 03:00:41 +07:00
|
|
|
unsigned long entries;
|
2008-05-13 02:20:42 +07:00
|
|
|
unsigned long saved_latency;
|
|
|
|
unsigned long critical_start;
|
|
|
|
unsigned long critical_end;
|
|
|
|
unsigned long critical_sequence;
|
|
|
|
unsigned long nice;
|
|
|
|
unsigned long policy;
|
|
|
|
unsigned long rt_priority;
|
2009-09-01 22:06:29 +07:00
|
|
|
unsigned long skipped_entries;
|
2016-12-22 02:32:01 +07:00
|
|
|
u64 preempt_timestamp;
|
2008-05-13 02:20:42 +07:00
|
|
|
pid_t pid;
|
2012-03-14 06:02:19 +07:00
|
|
|
kuid_t uid;
|
2008-05-13 02:20:42 +07:00
|
|
|
char comm[TASK_COMM_LEN];
|
2015-09-25 23:58:44 +07:00
|
|
|
|
|
|
|
bool ignore_pid;
|
2016-04-23 05:11:33 +07:00
|
|
|
#ifdef CONFIG_FUNCTION_TRACER
|
|
|
|
bool ftrace_ignore_pid;
|
|
|
|
#endif
|
2008-05-13 02:20:42 +07:00
|
|
|
};
|
|
|
|
|
2012-05-12 00:29:49 +07:00
|
|
|
struct tracer;
|
2015-10-01 01:27:31 +07:00
|
|
|
struct trace_option_dentry;
|
2012-05-12 00:29:49 +07:00
|
|
|
|
tracing: Consolidate max_tr into main trace_array structure
Currently, the way the latency tracers and snapshot feature works
is to have a separate trace_array called "max_tr" that holds the
snapshot buffer. For latency tracers, this snapshot buffer is used
to swap the running buffer with this buffer to save the current max
latency.
The only items needed for the max_tr is really just a copy of the buffer
itself, the per_cpu data pointers, the time_start timestamp that states
when the max latency was triggered, and the cpu that the max latency
was triggered on. All other fields in trace_array are unused by the
max_tr, making the max_tr mostly bloat.
This change removes the max_tr completely, and adds a new structure
called trace_buffer, that holds the buffer pointer, the per_cpu data
pointers, the time_start timestamp, and the cpu where the latency occurred.
The trace_array, now has two trace_buffers, one for the normal trace and
one for the max trace or snapshot. By doing this, not only do we remove
the bloat from the max_trace but the instances of traces can now use
their own snapshot feature and not have just the top level global_trace have
the snapshot feature and latency tracers for itself.
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-03-05 21:24:35 +07:00
|
|
|
struct trace_buffer {
|
|
|
|
struct trace_array *tr;
|
|
|
|
struct ring_buffer *buffer;
|
|
|
|
struct trace_array_cpu __percpu *data;
|
2016-12-22 02:32:01 +07:00
|
|
|
u64 time_start;
|
tracing: Consolidate max_tr into main trace_array structure
Currently, the way the latency tracers and snapshot feature works
is to have a separate trace_array called "max_tr" that holds the
snapshot buffer. For latency tracers, this snapshot buffer is used
to swap the running buffer with this buffer to save the current max
latency.
The only items needed for the max_tr is really just a copy of the buffer
itself, the per_cpu data pointers, the time_start timestamp that states
when the max latency was triggered, and the cpu that the max latency
was triggered on. All other fields in trace_array are unused by the
max_tr, making the max_tr mostly bloat.
This change removes the max_tr completely, and adds a new structure
called trace_buffer, that holds the buffer pointer, the per_cpu data
pointers, the time_start timestamp, and the cpu where the latency occurred.
The trace_array, now has two trace_buffers, one for the normal trace and
one for the max trace or snapshot. By doing this, not only do we remove
the bloat from the max_trace but the instances of traces can now use
their own snapshot feature and not have just the top level global_trace have
the snapshot feature and latency tracers for itself.
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-03-05 21:24:35 +07:00
|
|
|
int cpu;
|
|
|
|
};
|
|
|
|
|
2015-09-30 22:11:15 +07:00
|
|
|
#define TRACE_FLAGS_MAX_SIZE 32
|
|
|
|
|
2015-10-01 01:27:31 +07:00
|
|
|
struct trace_options {
|
|
|
|
struct tracer *tracer;
|
|
|
|
struct trace_option_dentry *topts;
|
|
|
|
};
|
|
|
|
|
2015-09-24 22:33:26 +07:00
|
|
|
struct trace_pid_list {
|
2016-04-14 03:27:49 +07:00
|
|
|
int pid_max;
|
|
|
|
unsigned long *pids;
|
2015-09-24 22:33:26 +07:00
|
|
|
};
|
|
|
|
|
2008-05-13 02:20:42 +07:00
|
|
|
/*
|
|
|
|
* The trace array - an array of per-CPU trace arrays. This is the
|
|
|
|
* highest level data structure that individual tracers deal with.
|
|
|
|
* They have on/off state as well:
|
|
|
|
*/
|
|
|
|
struct trace_array {
|
2012-05-04 10:09:03 +07:00
|
|
|
struct list_head list;
|
2012-08-04 03:10:49 +07:00
|
|
|
char *name;
|
tracing: Consolidate max_tr into main trace_array structure
Currently, the way the latency tracers and snapshot feature works
is to have a separate trace_array called "max_tr" that holds the
snapshot buffer. For latency tracers, this snapshot buffer is used
to swap the running buffer with this buffer to save the current max
latency.
The only items needed for the max_tr is really just a copy of the buffer
itself, the per_cpu data pointers, the time_start timestamp that states
when the max latency was triggered, and the cpu that the max latency
was triggered on. All other fields in trace_array are unused by the
max_tr, making the max_tr mostly bloat.
This change removes the max_tr completely, and adds a new structure
called trace_buffer, that holds the buffer pointer, the per_cpu data
pointers, the time_start timestamp, and the cpu where the latency occurred.
The trace_array, now has two trace_buffers, one for the normal trace and
one for the max trace or snapshot. By doing this, not only do we remove
the bloat from the max_trace but the instances of traces can now use
their own snapshot feature and not have just the top level global_trace have
the snapshot feature and latency tracers for itself.
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-03-05 21:24:35 +07:00
|
|
|
struct trace_buffer trace_buffer;
|
|
|
|
#ifdef CONFIG_TRACER_MAX_TRACE
|
|
|
|
/*
|
|
|
|
* The max_buffer is used to snapshot the trace when a maximum
|
|
|
|
* latency is reached, or when the user initiates a snapshot.
|
|
|
|
* Some tracers will use this to store a maximum trace while
|
|
|
|
* it continues examining live traces.
|
|
|
|
*
|
|
|
|
* The buffers for the max_buffer are set up the same as the trace_buffer
|
|
|
|
* When a snapshot is taken, the buffer of the max_buffer is swapped
|
|
|
|
* with the buffer of the trace_buffer and the buffers are reset for
|
|
|
|
* the trace_buffer so the tracing can continue.
|
|
|
|
*/
|
|
|
|
struct trace_buffer max_buffer;
|
2013-03-06 06:25:02 +07:00
|
|
|
bool allocated_snapshot;
|
2016-09-07 23:45:09 +07:00
|
|
|
#endif
|
|
|
|
#if defined(CONFIG_TRACER_MAX_TRACE) || defined(CONFIG_HWLAT_TRACER)
|
2014-01-14 23:28:38 +07:00
|
|
|
unsigned long max_latency;
|
tracing: Consolidate max_tr into main trace_array structure
Currently, the way the latency tracers and snapshot feature works
is to have a separate trace_array called "max_tr" that holds the
snapshot buffer. For latency tracers, this snapshot buffer is used
to swap the running buffer with this buffer to save the current max
latency.
The only items needed for the max_tr is really just a copy of the buffer
itself, the per_cpu data pointers, the time_start timestamp that states
when the max latency was triggered, and the cpu that the max latency
was triggered on. All other fields in trace_array are unused by the
max_tr, making the max_tr mostly bloat.
This change removes the max_tr completely, and adds a new structure
called trace_buffer, that holds the buffer pointer, the per_cpu data
pointers, the time_start timestamp, and the cpu where the latency occurred.
The trace_array, now has two trace_buffers, one for the normal trace and
one for the max trace or snapshot. By doing this, not only do we remove
the bloat from the max_trace but the instances of traces can now use
their own snapshot feature and not have just the top level global_trace have
the snapshot feature and latency tracers for itself.
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-03-05 21:24:35 +07:00
|
|
|
#endif
|
2015-09-24 22:33:26 +07:00
|
|
|
struct trace_pid_list __rcu *filtered_pids;
|
2014-01-14 22:04:59 +07:00
|
|
|
/*
|
|
|
|
* max_lock is used to protect the swapping of buffers
|
|
|
|
* when taking a max snapshot. The buffers themselves are
|
|
|
|
* protected by per_cpu spinlocks. But the action of the swap
|
|
|
|
* needs its own lock.
|
|
|
|
*
|
|
|
|
* This is defined as a arch_spinlock_t in order to help
|
|
|
|
* with performance when lockdep debugging is enabled.
|
|
|
|
*
|
|
|
|
* It is also used in other places outside the update_max_tr
|
|
|
|
* so it needs to be defined outside of the
|
|
|
|
* CONFIG_TRACER_MAX_TRACE.
|
|
|
|
*/
|
|
|
|
arch_spinlock_t max_lock;
|
2012-02-23 03:50:28 +07:00
|
|
|
int buffer_disabled;
|
2012-08-09 01:48:20 +07:00
|
|
|
#ifdef CONFIG_FTRACE_SYSCALLS
|
|
|
|
int sys_refcount_enter;
|
|
|
|
int sys_refcount_exit;
|
2015-05-05 21:09:53 +07:00
|
|
|
struct trace_event_file __rcu *enter_syscall_files[NR_syscalls];
|
|
|
|
struct trace_event_file __rcu *exit_syscall_files[NR_syscalls];
|
2012-08-09 01:48:20 +07:00
|
|
|
#endif
|
2012-05-12 00:29:49 +07:00
|
|
|
int stop_count;
|
|
|
|
int clock_id;
|
2015-10-01 01:27:31 +07:00
|
|
|
int nr_topts;
|
2012-05-12 00:29:49 +07:00
|
|
|
struct tracer *current_trace;
|
2015-09-30 20:42:05 +07:00
|
|
|
unsigned int trace_flags;
|
2015-09-30 22:11:15 +07:00
|
|
|
unsigned char trace_flags_index[TRACE_FLAGS_MAX_SIZE];
|
2012-05-04 10:09:03 +07:00
|
|
|
unsigned int flags;
|
2012-05-12 00:29:49 +07:00
|
|
|
raw_spinlock_t start_lock;
|
2012-05-04 10:09:03 +07:00
|
|
|
struct dentry *dir;
|
2012-05-12 00:29:49 +07:00
|
|
|
struct dentry *options;
|
|
|
|
struct dentry *percpu_dir;
|
2012-05-04 10:09:03 +07:00
|
|
|
struct dentry *event_dir;
|
2015-10-01 01:27:31 +07:00
|
|
|
struct trace_options *topts;
|
2012-05-04 10:09:03 +07:00
|
|
|
struct list_head systems;
|
|
|
|
struct list_head events;
|
2013-08-08 23:47:45 +07:00
|
|
|
cpumask_var_t tracing_cpumask; /* only trace on set CPUs */
|
2013-03-07 03:27:24 +07:00
|
|
|
int ref;
|
2013-11-08 08:08:58 +07:00
|
|
|
#ifdef CONFIG_FUNCTION_TRACER
|
|
|
|
struct ftrace_ops *ops;
|
2016-04-23 05:11:33 +07:00
|
|
|
struct trace_pid_list __rcu *function_pids;
|
2013-11-08 08:08:58 +07:00
|
|
|
/* function tracing enabled */
|
|
|
|
int function_enabled;
|
|
|
|
#endif
|
2008-05-13 02:20:42 +07:00
|
|
|
};
|
|
|
|
|
2012-05-04 10:09:03 +07:00
|
|
|
enum {
|
|
|
|
TRACE_ARRAY_FL_GLOBAL = (1 << 0)
|
|
|
|
};
|
|
|
|
|
|
|
|
extern struct list_head ftrace_trace_arrays;
|
|
|
|
|
2013-07-02 09:37:54 +07:00
|
|
|
extern struct mutex trace_types_lock;
|
|
|
|
|
2013-07-03 02:30:53 +07:00
|
|
|
extern int trace_array_get(struct trace_array *tr);
|
|
|
|
extern void trace_array_put(struct trace_array *tr);
|
|
|
|
|
2012-05-04 10:09:03 +07:00
|
|
|
/*
|
|
|
|
* The global tracer (top) should be the first trace array added,
|
|
|
|
* but we check the flag anyway.
|
|
|
|
*/
|
|
|
|
static inline struct trace_array *top_trace_array(void)
|
|
|
|
{
|
|
|
|
struct trace_array *tr;
|
|
|
|
|
2014-06-11 00:53:50 +07:00
|
|
|
if (list_empty(&ftrace_trace_arrays))
|
2014-06-06 05:35:17 +07:00
|
|
|
return NULL;
|
|
|
|
|
2012-05-04 10:09:03 +07:00
|
|
|
tr = list_entry(ftrace_trace_arrays.prev,
|
|
|
|
typeof(*tr), list);
|
|
|
|
WARN_ON(!(tr->flags & TRACE_ARRAY_FL_GLOBAL));
|
|
|
|
return tr;
|
|
|
|
}
|
|
|
|
|
2008-10-01 21:52:51 +07:00
|
|
|
#define FTRACE_CMP_TYPE(var, type) \
|
|
|
|
__builtin_types_compatible_p(typeof(var), type *)
|
|
|
|
|
|
|
|
#undef IF_ASSIGN
|
|
|
|
#define IF_ASSIGN(var, entry, etype, id) \
|
|
|
|
if (FTRACE_CMP_TYPE(var, etype)) { \
|
|
|
|
var = (typeof(var))(entry); \
|
|
|
|
WARN_ON(id && (entry)->type != id); \
|
|
|
|
break; \
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Will cause compile errors if type is not found. */
|
|
|
|
extern void __ftrace_bad_type(void);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The trace_assign_type is a verifier that the entry type is
|
|
|
|
* the same as the type being assigned. To add new types simply
|
|
|
|
* add a line with the following format:
|
|
|
|
*
|
|
|
|
* IF_ASSIGN(var, ent, type, id);
|
|
|
|
*
|
|
|
|
* Where "type" is the trace type that includes the trace_entry
|
|
|
|
* as the "ent" item. And "id" is the trace identifier that is
|
|
|
|
* used in the trace_type enum.
|
|
|
|
*
|
|
|
|
* If the type can have more than one id, then use zero.
|
|
|
|
*/
|
|
|
|
#define trace_assign_type(var, ent) \
|
|
|
|
do { \
|
|
|
|
IF_ASSIGN(var, ent, struct ftrace_entry, TRACE_FN); \
|
|
|
|
IF_ASSIGN(var, ent, struct ctx_switch_entry, 0); \
|
|
|
|
IF_ASSIGN(var, ent, struct stack_entry, TRACE_STACK); \
|
2008-11-22 18:28:47 +07:00
|
|
|
IF_ASSIGN(var, ent, struct userstack_entry, TRACE_USER_STACK);\
|
2008-10-01 21:52:51 +07:00
|
|
|
IF_ASSIGN(var, ent, struct print_entry, TRACE_PRINT); \
|
2009-03-13 00:24:49 +07:00
|
|
|
IF_ASSIGN(var, ent, struct bprint_entry, TRACE_BPRINT); \
|
2013-03-09 09:02:34 +07:00
|
|
|
IF_ASSIGN(var, ent, struct bputs_entry, TRACE_BPUTS); \
|
2016-06-23 23:45:36 +07:00
|
|
|
IF_ASSIGN(var, ent, struct hwlat_entry, TRACE_HWLAT); \
|
2016-07-07 02:25:08 +07:00
|
|
|
IF_ASSIGN(var, ent, struct raw_data_entry, TRACE_RAW_DATA);\
|
2008-10-01 21:52:51 +07:00
|
|
|
IF_ASSIGN(var, ent, struct trace_mmiotrace_rw, \
|
|
|
|
TRACE_MMIO_RW); \
|
|
|
|
IF_ASSIGN(var, ent, struct trace_mmiotrace_map, \
|
|
|
|
TRACE_MMIO_MAP); \
|
2008-11-13 03:24:24 +07:00
|
|
|
IF_ASSIGN(var, ent, struct trace_branch, TRACE_BRANCH); \
|
2008-11-26 06:57:25 +07:00
|
|
|
IF_ASSIGN(var, ent, struct ftrace_graph_ent_entry, \
|
|
|
|
TRACE_GRAPH_ENT); \
|
|
|
|
IF_ASSIGN(var, ent, struct ftrace_graph_ret_entry, \
|
|
|
|
TRACE_GRAPH_RET); \
|
2008-10-01 21:52:51 +07:00
|
|
|
__ftrace_bad_type(); \
|
|
|
|
} while (0)
|
2008-09-30 01:18:34 +07:00
|
|
|
|
2008-11-18 01:23:42 +07:00
|
|
|
/*
|
|
|
|
* An option specific to a tracer. This is a boolean value.
|
|
|
|
* The bit is the bit index that sets its value on the
|
|
|
|
* flags value in struct tracer_flags.
|
|
|
|
*/
|
|
|
|
struct tracer_opt {
|
2009-03-06 23:52:03 +07:00
|
|
|
const char *name; /* Will appear on the trace_options file */
|
|
|
|
u32 bit; /* Mask assigned in val field in tracer_flags */
|
2008-11-18 01:23:42 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The set of specific options for a tracer. Your tracer
|
|
|
|
* have to set the initial value of the flags val.
|
|
|
|
*/
|
|
|
|
struct tracer_flags {
|
|
|
|
u32 val;
|
2009-03-06 23:52:03 +07:00
|
|
|
struct tracer_opt *opts;
|
2016-03-08 20:37:01 +07:00
|
|
|
struct tracer *trace;
|
2008-11-18 01:23:42 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
/* Makes more easy to define a tracer opt */
|
|
|
|
#define TRACER_OPT(s, b) .name = #s, .bit = b
|
|
|
|
|
2009-01-09 01:03:56 +07:00
|
|
|
|
2015-09-30 04:31:55 +07:00
|
|
|
struct trace_option_dentry {
|
|
|
|
struct tracer_opt *opt;
|
|
|
|
struct tracer_flags *flags;
|
|
|
|
struct trace_array *tr;
|
|
|
|
struct dentry *entry;
|
|
|
|
};
|
|
|
|
|
2009-02-11 08:25:00 +07:00
|
|
|
/**
|
2015-01-21 00:13:40 +07:00
|
|
|
* struct tracer - a specific tracer and its callbacks to interact with tracefs
|
2009-02-11 08:25:00 +07:00
|
|
|
* @name: the name chosen to select it on the available_tracers file
|
|
|
|
* @init: called when one switches to this tracer (echo name > current_tracer)
|
|
|
|
* @reset: called when one switches to another tracer
|
2015-12-22 21:44:33 +07:00
|
|
|
* @start: called when tracing is unpaused (echo 1 > tracing_on)
|
|
|
|
* @stop: called when tracing is paused (echo 0 > tracing_on)
|
2014-07-18 18:17:27 +07:00
|
|
|
* @update_thresh: called when tracing_thresh is updated
|
2009-02-11 08:25:00 +07:00
|
|
|
* @open: called when the trace file is opened
|
|
|
|
* @pipe_open: called when the trace_pipe file is opened
|
|
|
|
* @close: called when the trace file is released
|
2009-12-07 21:06:24 +07:00
|
|
|
* @pipe_close: called when the trace_pipe file is released
|
2009-02-11 08:25:00 +07:00
|
|
|
* @read: override the default read callback on trace_pipe
|
|
|
|
* @splice_read: override the default splice_read callback on trace_pipe
|
|
|
|
* @selftest: selftest to run on boot (see trace_selftest.c)
|
|
|
|
* @print_headers: override the first lines that describe your columns
|
|
|
|
* @print_line: callback that prints a trace
|
|
|
|
* @set_flag: signals one of your private flags changed (trace_options file)
|
|
|
|
* @flags: your private flags
|
2008-05-13 02:20:42 +07:00
|
|
|
*/
|
|
|
|
struct tracer {
|
|
|
|
const char *name;
|
2008-11-16 11:57:26 +07:00
|
|
|
int (*init)(struct trace_array *tr);
|
2008-05-13 02:20:42 +07:00
|
|
|
void (*reset)(struct trace_array *tr);
|
ftrace: restructure tracing start/stop infrastructure
Impact: change where tracing is started up and stopped
Currently, when a new tracer is selected via echo'ing a tracer name into
the current_tracer file, the startup is only done if tracing_enabled is
set to one. If tracing_enabled is changed to zero (by echo'ing 0 into
the tracing_enabled file) a full shutdown is performed.
The full startup and shutdown of a tracer can be expensive and the
user can lose out traces when echo'ing in 0 to the tracing_enabled file,
because the process takes too long. There can also be places that
the user would like to start and stop the tracer several times and
doing the full startup and shutdown of a tracer might be too expensive.
This patch performs the full startup and shutdown when a tracer is
selected. It also adds a way to do a quick start or stop of a tracer.
The quick version is just a flag that prevents the tracing from
taking place, but the overhead of the code is still there.
For example, the startup of a tracer may enable tracepoints, or enable
the function tracer. The stop and start will just set a flag to
have the tracer ignore the calls when the tracepoint or function trace
is called. The overhead of the tracer may still be present when
the tracer is stopped, but no tracing will occur. Setting the tracer
to the 'nop' tracer (or any other tracer) will perform the shutdown
of the tracer which will disable the tracepoint or disable the
function tracer.
The tracing_enabled file will simply start or stop tracing.
This change is all internal. The end result for the user should be the same
as before. If tracing_enabled is not set, no trace will happen.
If tracing_enabled is set, then the trace will happen. The tracing_enabled
variable is static between tracers. Enabling tracing_enabled and
going to another tracer will keep tracing_enabled enabled. Same
is true with disabling tracing_enabled.
This patch will now provide a fast start/stop method to the users
for enabling or disabling tracing.
Note: There were two methods to the struct tracer that were never
used: The methods start and stop. These were to be used as a hook
to the reading of the trace output, but ended up not being
necessary. These two methods are now used to enable the start
and stop of each tracer, in case the tracer needs to do more than
just not write into the buffer. For example, the irqsoff tracer
must stop recording max latencies when tracing is stopped.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-11-06 04:05:44 +07:00
|
|
|
void (*start)(struct trace_array *tr);
|
|
|
|
void (*stop)(struct trace_array *tr);
|
2014-07-18 18:17:27 +07:00
|
|
|
int (*update_thresh)(struct trace_array *tr);
|
2008-05-13 02:20:42 +07:00
|
|
|
void (*open)(struct trace_iterator *iter);
|
2008-05-13 02:21:01 +07:00
|
|
|
void (*pipe_open)(struct trace_iterator *iter);
|
2008-05-13 02:20:42 +07:00
|
|
|
void (*close)(struct trace_iterator *iter);
|
2009-12-07 21:06:24 +07:00
|
|
|
void (*pipe_close)(struct trace_iterator *iter);
|
2008-05-13 02:21:01 +07:00
|
|
|
ssize_t (*read)(struct trace_iterator *iter,
|
|
|
|
struct file *filp, char __user *ubuf,
|
|
|
|
size_t cnt, loff_t *ppos);
|
2009-02-09 13:15:56 +07:00
|
|
|
ssize_t (*splice_read)(struct trace_iterator *iter,
|
|
|
|
struct file *filp,
|
|
|
|
loff_t *ppos,
|
|
|
|
struct pipe_inode_info *pipe,
|
|
|
|
size_t len,
|
|
|
|
unsigned int flags);
|
2008-05-13 02:20:44 +07:00
|
|
|
#ifdef CONFIG_FTRACE_STARTUP_TEST
|
|
|
|
int (*selftest)(struct tracer *trace,
|
|
|
|
struct trace_array *tr);
|
|
|
|
#endif
|
2008-11-25 15:12:31 +07:00
|
|
|
void (*print_header)(struct seq_file *m);
|
2008-09-30 01:18:34 +07:00
|
|
|
enum print_line_t (*print_line)(struct trace_iterator *iter);
|
2008-11-18 01:23:42 +07:00
|
|
|
/* If you handled the flag setting, return 0 */
|
2014-01-10 23:13:54 +07:00
|
|
|
int (*set_flag)(struct trace_array *tr,
|
|
|
|
u32 old_flags, u32 bit, int set);
|
2013-03-15 02:03:53 +07:00
|
|
|
/* Return 0 if OK with change, else return non-zero */
|
2014-01-11 05:51:01 +07:00
|
|
|
int (*flag_changed)(struct trace_array *tr,
|
2013-03-15 02:03:53 +07:00
|
|
|
u32 mask, int set);
|
2008-05-13 02:20:42 +07:00
|
|
|
struct tracer *next;
|
2009-03-06 23:52:03 +07:00
|
|
|
struct tracer_flags *flags;
|
2014-01-14 20:52:35 +07:00
|
|
|
int enabled;
|
2014-12-16 08:13:31 +07:00
|
|
|
int ref;
|
2012-10-02 15:27:10 +07:00
|
|
|
bool print_max;
|
2013-11-07 10:42:48 +07:00
|
|
|
bool allow_instances;
|
tracing: Consolidate max_tr into main trace_array structure
Currently, the way the latency tracers and snapshot feature works
is to have a separate trace_array called "max_tr" that holds the
snapshot buffer. For latency tracers, this snapshot buffer is used
to swap the running buffer with this buffer to save the current max
latency.
The only items needed for the max_tr is really just a copy of the buffer
itself, the per_cpu data pointers, the time_start timestamp that states
when the max latency was triggered, and the cpu that the max latency
was triggered on. All other fields in trace_array are unused by the
max_tr, making the max_tr mostly bloat.
This change removes the max_tr completely, and adds a new structure
called trace_buffer, that holds the buffer pointer, the per_cpu data
pointers, the time_start timestamp, and the cpu where the latency occurred.
The trace_array, now has two trace_buffers, one for the normal trace and
one for the max trace or snapshot. By doing this, not only do we remove
the bloat from the max_trace but the instances of traces can now use
their own snapshot feature and not have just the top level global_trace have
the snapshot feature and latency tracers for itself.
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-03-05 21:24:35 +07:00
|
|
|
#ifdef CONFIG_TRACER_MAX_TRACE
|
2012-10-02 15:27:10 +07:00
|
|
|
bool use_max_tr;
|
tracing: Consolidate max_tr into main trace_array structure
Currently, the way the latency tracers and snapshot feature works
is to have a separate trace_array called "max_tr" that holds the
snapshot buffer. For latency tracers, this snapshot buffer is used
to swap the running buffer with this buffer to save the current max
latency.
The only items needed for the max_tr is really just a copy of the buffer
itself, the per_cpu data pointers, the time_start timestamp that states
when the max latency was triggered, and the cpu that the max latency
was triggered on. All other fields in trace_array are unused by the
max_tr, making the max_tr mostly bloat.
This change removes the max_tr completely, and adds a new structure
called trace_buffer, that holds the buffer pointer, the per_cpu data
pointers, the time_start timestamp, and the cpu where the latency occurred.
The trace_array, now has two trace_buffers, one for the normal trace and
one for the max trace or snapshot. By doing this, not only do we remove
the bloat from the max_trace but the instances of traces can now use
their own snapshot feature and not have just the top level global_trace have
the snapshot feature and latency tracers for itself.
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-03-05 21:24:35 +07:00
|
|
|
#endif
|
2008-05-13 02:20:42 +07:00
|
|
|
};
|
|
|
|
|
2009-03-03 02:04:40 +07:00
|
|
|
|
2011-06-15 06:02:29 +07:00
|
|
|
/* Only current can touch trace_recursion */
|
|
|
|
|
2012-11-03 04:47:21 +07:00
|
|
|
/*
|
|
|
|
* For function tracing recursion:
|
|
|
|
* The order of these bits are important.
|
|
|
|
*
|
|
|
|
* When function tracing occurs, the following steps are made:
|
|
|
|
* If arch does not support a ftrace feature:
|
|
|
|
* call internal function (uses INTERNAL bits) which calls...
|
|
|
|
* If callback is registered to the "global" list, the list
|
|
|
|
* function is called and recursion checks the GLOBAL bits.
|
|
|
|
* then this function calls...
|
|
|
|
* The function callback, which can use the FTRACE bits to
|
|
|
|
* check for recursion.
|
|
|
|
*
|
|
|
|
* Now if the arch does not suppport a feature, and it calls
|
|
|
|
* the global list function which calls the ftrace callback
|
|
|
|
* all three of these steps will do a recursion protection.
|
|
|
|
* There's no reason to do one if the previous caller already
|
|
|
|
* did. The recursion that we are protecting against will
|
|
|
|
* go through the same steps again.
|
|
|
|
*
|
|
|
|
* To prevent the multiple recursion checks, if a recursion
|
|
|
|
* bit is set that is higher than the MAX bit of the current
|
|
|
|
* check, then we know that the check was made by the previous
|
|
|
|
* caller, and we can skip the current check.
|
|
|
|
*/
|
2012-11-03 04:32:25 +07:00
|
|
|
enum {
|
2012-11-03 05:33:05 +07:00
|
|
|
TRACE_BUFFER_BIT,
|
|
|
|
TRACE_BUFFER_NMI_BIT,
|
|
|
|
TRACE_BUFFER_IRQ_BIT,
|
|
|
|
TRACE_BUFFER_SIRQ_BIT,
|
|
|
|
|
|
|
|
/* Start of function recursion bits */
|
|
|
|
TRACE_FTRACE_BIT,
|
2012-11-03 04:47:21 +07:00
|
|
|
TRACE_FTRACE_NMI_BIT,
|
|
|
|
TRACE_FTRACE_IRQ_BIT,
|
|
|
|
TRACE_FTRACE_SIRQ_BIT,
|
2012-11-03 04:32:25 +07:00
|
|
|
|
2014-01-11 05:01:58 +07:00
|
|
|
/* INTERNAL_BITs must be greater than FTRACE_BITs */
|
2012-11-03 04:47:21 +07:00
|
|
|
TRACE_INTERNAL_BIT,
|
|
|
|
TRACE_INTERNAL_NMI_BIT,
|
|
|
|
TRACE_INTERNAL_IRQ_BIT,
|
|
|
|
TRACE_INTERNAL_SIRQ_BIT,
|
|
|
|
|
2015-07-08 02:05:03 +07:00
|
|
|
TRACE_BRANCH_BIT,
|
2011-06-15 06:02:29 +07:00
|
|
|
/*
|
|
|
|
* Abuse of the trace_recursion.
|
|
|
|
* As we need a way to maintain state if we are tracing the function
|
|
|
|
* graph in irq because we want to trace a particular function that
|
|
|
|
* was called in irq context but we have irq tracing off. Since this
|
|
|
|
* can only be modified by current, we can reuse trace_recursion.
|
|
|
|
*/
|
2012-11-03 04:32:25 +07:00
|
|
|
TRACE_IRQ_BIT,
|
|
|
|
};
|
2011-06-15 06:02:29 +07:00
|
|
|
|
2012-11-03 04:32:25 +07:00
|
|
|
#define trace_recursion_set(bit) do { (current)->trace_recursion |= (1<<(bit)); } while (0)
|
|
|
|
#define trace_recursion_clear(bit) do { (current)->trace_recursion &= ~(1<<(bit)); } while (0)
|
|
|
|
#define trace_recursion_test(bit) ((current)->trace_recursion & (1<<(bit)))
|
2011-06-15 06:02:29 +07:00
|
|
|
|
2012-11-03 04:47:21 +07:00
|
|
|
#define TRACE_CONTEXT_BITS 4
|
|
|
|
|
|
|
|
#define TRACE_FTRACE_START TRACE_FTRACE_BIT
|
|
|
|
#define TRACE_FTRACE_MAX ((1 << (TRACE_FTRACE_START + TRACE_CONTEXT_BITS)) - 1)
|
|
|
|
|
|
|
|
#define TRACE_LIST_START TRACE_INTERNAL_BIT
|
|
|
|
#define TRACE_LIST_MAX ((1 << (TRACE_LIST_START + TRACE_CONTEXT_BITS)) - 1)
|
|
|
|
|
|
|
|
#define TRACE_CONTEXT_MASK TRACE_LIST_MAX
|
|
|
|
|
|
|
|
static __always_inline int trace_get_context_bit(void)
|
|
|
|
{
|
|
|
|
int bit;
|
|
|
|
|
|
|
|
if (in_interrupt()) {
|
|
|
|
if (in_nmi())
|
|
|
|
bit = 0;
|
|
|
|
|
|
|
|
else if (in_irq())
|
|
|
|
bit = 1;
|
|
|
|
else
|
|
|
|
bit = 2;
|
|
|
|
} else
|
|
|
|
bit = 3;
|
|
|
|
|
|
|
|
return bit;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __always_inline int trace_test_and_set_recursion(int start, int max)
|
|
|
|
{
|
|
|
|
unsigned int val = current->trace_recursion;
|
|
|
|
int bit;
|
|
|
|
|
|
|
|
/* A previous recursion check was made */
|
|
|
|
if ((val & TRACE_CONTEXT_MASK) > max)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
bit = trace_get_context_bit() + start;
|
|
|
|
if (unlikely(val & (1 << bit)))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
val |= 1 << bit;
|
|
|
|
current->trace_recursion = val;
|
|
|
|
barrier();
|
|
|
|
|
|
|
|
return bit;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __always_inline void trace_clear_recursion(int bit)
|
|
|
|
{
|
|
|
|
unsigned int val = current->trace_recursion;
|
|
|
|
|
|
|
|
if (!bit)
|
|
|
|
return;
|
|
|
|
|
|
|
|
bit = 1 << bit;
|
|
|
|
val &= ~bit;
|
|
|
|
|
|
|
|
barrier();
|
|
|
|
current->trace_recursion = val;
|
|
|
|
}
|
|
|
|
|
2012-06-28 07:46:14 +07:00
|
|
|
static inline struct ring_buffer_iter *
|
|
|
|
trace_buffer_iter(struct trace_iterator *iter, int cpu)
|
|
|
|
{
|
|
|
|
if (iter->buffer_iter && iter->buffer_iter[cpu])
|
|
|
|
return iter->buffer_iter[cpu];
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-02-06 03:02:00 +07:00
|
|
|
int tracer_init(struct tracer *t, struct trace_array *tr);
|
ftrace: restructure tracing start/stop infrastructure
Impact: change where tracing is started up and stopped
Currently, when a new tracer is selected via echo'ing a tracer name into
the current_tracer file, the startup is only done if tracing_enabled is
set to one. If tracing_enabled is changed to zero (by echo'ing 0 into
the tracing_enabled file) a full shutdown is performed.
The full startup and shutdown of a tracer can be expensive and the
user can lose out traces when echo'ing in 0 to the tracing_enabled file,
because the process takes too long. There can also be places that
the user would like to start and stop the tracer several times and
doing the full startup and shutdown of a tracer might be too expensive.
This patch performs the full startup and shutdown when a tracer is
selected. It also adds a way to do a quick start or stop of a tracer.
The quick version is just a flag that prevents the tracing from
taking place, but the overhead of the code is still there.
For example, the startup of a tracer may enable tracepoints, or enable
the function tracer. The stop and start will just set a flag to
have the tracer ignore the calls when the tracepoint or function trace
is called. The overhead of the tracer may still be present when
the tracer is stopped, but no tracing will occur. Setting the tracer
to the 'nop' tracer (or any other tracer) will perform the shutdown
of the tracer which will disable the tracepoint or disable the
function tracer.
The tracing_enabled file will simply start or stop tracing.
This change is all internal. The end result for the user should be the same
as before. If tracing_enabled is not set, no trace will happen.
If tracing_enabled is set, then the trace will happen. The tracing_enabled
variable is static between tracers. Enabling tracing_enabled and
going to another tracer will keep tracing_enabled enabled. Same
is true with disabling tracing_enabled.
This patch will now provide a fast start/stop method to the users
for enabling or disabling tracing.
Note: There were two methods to the struct tracer that were never
used: The methods start and stop. These were to be used as a hook
to the reading of the trace output, but ended up not being
necessary. These two methods are now used to enable the start
and stop of each tracer, in case the tracer needs to do more than
just not write into the buffer. For example, the irqsoff tracer
must stop recording max latencies when tracing is stopped.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-11-06 04:05:44 +07:00
|
|
|
int tracing_is_enabled(void);
|
tracing: Consolidate max_tr into main trace_array structure
Currently, the way the latency tracers and snapshot feature works
is to have a separate trace_array called "max_tr" that holds the
snapshot buffer. For latency tracers, this snapshot buffer is used
to swap the running buffer with this buffer to save the current max
latency.
The only items needed for the max_tr is really just a copy of the buffer
itself, the per_cpu data pointers, the time_start timestamp that states
when the max latency was triggered, and the cpu that the max latency
was triggered on. All other fields in trace_array are unused by the
max_tr, making the max_tr mostly bloat.
This change removes the max_tr completely, and adds a new structure
called trace_buffer, that holds the buffer pointer, the per_cpu data
pointers, the time_start timestamp, and the cpu where the latency occurred.
The trace_array, now has two trace_buffers, one for the normal trace and
one for the max trace or snapshot. By doing this, not only do we remove
the bloat from the max_trace but the instances of traces can now use
their own snapshot feature and not have just the top level global_trace have
the snapshot feature and latency tracers for itself.
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-03-05 21:24:35 +07:00
|
|
|
void tracing_reset(struct trace_buffer *buf, int cpu);
|
|
|
|
void tracing_reset_online_cpus(struct trace_buffer *buf);
|
2009-05-07 08:54:09 +07:00
|
|
|
void tracing_reset_current(int cpu);
|
2013-03-05 11:26:06 +07:00
|
|
|
void tracing_reset_all_online_cpus(void);
|
2008-05-13 02:20:42 +07:00
|
|
|
int tracing_open_generic(struct inode *inode, struct file *filp);
|
2013-10-19 07:15:54 +07:00
|
|
|
bool tracing_is_disabled(void);
|
2016-06-23 23:45:36 +07:00
|
|
|
int tracer_tracing_is_on(struct trace_array *tr);
|
2009-03-27 06:25:38 +07:00
|
|
|
struct dentry *trace_create_file(const char *name,
|
2011-07-24 15:33:43 +07:00
|
|
|
umode_t mode,
|
2009-03-27 06:25:38 +07:00
|
|
|
struct dentry *parent,
|
|
|
|
void *data,
|
|
|
|
const struct file_operations *fops);
|
|
|
|
|
2008-05-13 02:20:42 +07:00
|
|
|
struct dentry *tracing_init_dentry(void);
|
2008-05-13 02:20:49 +07:00
|
|
|
|
tracing: Introduce trace_buffer_{lock_reserve,unlock_commit}
Impact: new API
These new functions do what previously was being open coded, reducing
the number of details ftrace plugin writers have to worry about.
It also standardizes the handling of stacktrace, userstacktrace and
other trace options we may introduce in the future.
With this patch, for instance, the blk tracer (and some others already
in the tree) can use the "userstacktrace" /d/tracing/trace_options
facility.
$ codiff /tmp/vmlinux.before /tmp/vmlinux.after
linux-2.6-tip/kernel/trace/trace.c:
trace_vprintk | -5
trace_graph_return | -22
trace_graph_entry | -26
trace_function | -45
__ftrace_trace_stack | -27
ftrace_trace_userstack | -29
tracing_sched_switch_trace | -66
tracing_stop | +1
trace_seq_to_user | -1
ftrace_trace_special | -63
ftrace_special | +1
tracing_sched_wakeup_trace | -70
tracing_reset_online_cpus | -1
13 functions changed, 2 bytes added, 355 bytes removed, diff: -353
linux-2.6-tip/block/blktrace.c:
__blk_add_trace | -58
1 function changed, 58 bytes removed, diff: -58
linux-2.6-tip/kernel/trace/trace.c:
trace_buffer_lock_reserve | +88
trace_buffer_unlock_commit | +86
2 functions changed, 174 bytes added, diff: +174
/tmp/vmlinux.after:
16 functions changed, 176 bytes added, 413 bytes removed, diff: -237
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Acked-by: Frédéric Weisbecker <fweisbec@gmail.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-02-06 01:14:13 +07:00
|
|
|
struct ring_buffer_event;
|
|
|
|
|
2009-09-03 01:17:06 +07:00
|
|
|
struct ring_buffer_event *
|
|
|
|
trace_buffer_lock_reserve(struct ring_buffer *buffer,
|
|
|
|
int type,
|
|
|
|
unsigned long len,
|
|
|
|
unsigned long flags,
|
|
|
|
int pc);
|
tracing: Introduce trace_buffer_{lock_reserve,unlock_commit}
Impact: new API
These new functions do what previously was being open coded, reducing
the number of details ftrace plugin writers have to worry about.
It also standardizes the handling of stacktrace, userstacktrace and
other trace options we may introduce in the future.
With this patch, for instance, the blk tracer (and some others already
in the tree) can use the "userstacktrace" /d/tracing/trace_options
facility.
$ codiff /tmp/vmlinux.before /tmp/vmlinux.after
linux-2.6-tip/kernel/trace/trace.c:
trace_vprintk | -5
trace_graph_return | -22
trace_graph_entry | -26
trace_function | -45
__ftrace_trace_stack | -27
ftrace_trace_userstack | -29
tracing_sched_switch_trace | -66
tracing_stop | +1
trace_seq_to_user | -1
ftrace_trace_special | -63
ftrace_special | +1
tracing_sched_wakeup_trace | -70
tracing_reset_online_cpus | -1
13 functions changed, 2 bytes added, 355 bytes removed, diff: -353
linux-2.6-tip/block/blktrace.c:
__blk_add_trace | -58
1 function changed, 58 bytes removed, diff: -58
linux-2.6-tip/kernel/trace/trace.c:
trace_buffer_lock_reserve | +88
trace_buffer_unlock_commit | +86
2 functions changed, 174 bytes added, diff: +174
/tmp/vmlinux.after:
16 functions changed, 176 bytes added, 413 bytes removed, diff: -237
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Acked-by: Frédéric Weisbecker <fweisbec@gmail.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-02-06 01:14:13 +07:00
|
|
|
|
2008-09-17 01:56:41 +07:00
|
|
|
struct trace_entry *tracing_get_trace_entry(struct trace_array *tr,
|
|
|
|
struct trace_array_cpu *data);
|
2009-02-03 05:29:21 +07:00
|
|
|
|
|
|
|
struct trace_entry *trace_find_next_entry(struct trace_iterator *iter,
|
|
|
|
int *ent_cpu, u64 *ent_ts);
|
|
|
|
|
2016-11-24 08:28:38 +07:00
|
|
|
void trace_buffer_unlock_commit_nostack(struct ring_buffer *buffer,
|
|
|
|
struct ring_buffer_event *event);
|
2012-10-11 23:14:25 +07:00
|
|
|
|
2010-08-05 21:22:23 +07:00
|
|
|
int trace_empty(struct trace_iterator *iter);
|
|
|
|
|
|
|
|
void *trace_find_next_entry_inc(struct trace_iterator *iter);
|
|
|
|
|
|
|
|
void trace_init_global_iter(struct trace_iterator *iter);
|
|
|
|
|
|
|
|
void tracing_iter_reset(struct trace_iterator *iter, int cpu);
|
|
|
|
|
2008-05-13 02:20:49 +07:00
|
|
|
void trace_function(struct trace_array *tr,
|
|
|
|
unsigned long ip,
|
|
|
|
unsigned long parent_ip,
|
2008-10-02 00:14:09 +07:00
|
|
|
unsigned long flags, int pc);
|
2010-09-23 19:00:52 +07:00
|
|
|
void trace_graph_function(struct trace_array *tr,
|
|
|
|
unsigned long ip,
|
|
|
|
unsigned long parent_ip,
|
|
|
|
unsigned long flags, int pc);
|
tracing/latency: Fix header output for latency tracers
In case the the graph tracer (CONFIG_FUNCTION_GRAPH_TRACER) or even the
function tracer (CONFIG_FUNCTION_TRACER) are not set, the latency tracers
do not display proper latency header.
The involved/fixed latency tracers are:
wakeup_rt
wakeup
preemptirqsoff
preemptoff
irqsoff
The patch adds proper handling of tracer configuration options for latency
tracers, and displaying correct header info accordingly.
* The current output (for wakeup tracer) with both graph and function
tracers disabled is:
# tracer: wakeup
#
<idle>-0 0d.h5 1us+: 0:120:R + [000] 7: 0:R watchdog/0
<idle>-0 0d.h5 3us+: ttwu_do_activate.clone.1 <-try_to_wake_up
...
* The fixed output is:
# tracer: wakeup
#
# wakeup latency trace v1.1.5 on 3.1.0-tip+
# --------------------------------------------------------------------
# latency: 55 us, #4/4, CPU#0 | (M:preempt VP:0, KP:0, SP:0 HP:0 #P:2)
# -----------------
# | task: migration/0-6 (uid:0 nice:0 policy:1 rt_prio:99)
# -----------------
#
# _------=> CPU#
# / _-----=> irqs-off
# | / _----=> need-resched
# || / _---=> hardirq/softirq
# ||| / _--=> preempt-depth
# |||| / delay
# cmd pid ||||| time | caller
# \ / ||||| \ | /
cat-1129 0d..4 1us : 1129:120:R + [000] 6: 0:R migration/0
cat-1129 0d..4 2us+: ttwu_do_activate.clone.1 <-try_to_wake_up
* The current output (for wakeup tracer) with only function
tracer enabled is:
# tracer: wakeup
#
cat-1140 0d..4 1us+: 1140:120:R + [000] 6: 0:R migration/0
cat-1140 0d..4 2us : ttwu_do_activate.clone.1 <-try_to_wake_up
* The fixed output is:
# tracer: wakeup
#
# wakeup latency trace v1.1.5 on 3.1.0-tip+
# --------------------------------------------------------------------
# latency: 207 us, #109/109, CPU#1 | (M:preempt VP:0, KP:0, SP:0 HP:0 #P:2)
# -----------------
# | task: watchdog/1-12 (uid:0 nice:0 policy:1 rt_prio:99)
# -----------------
#
# _------=> CPU#
# / _-----=> irqs-off
# | / _----=> need-resched
# || / _---=> hardirq/softirq
# ||| / _--=> preempt-depth
# |||| / delay
# cmd pid ||||| time | caller
# \ / ||||| \ | /
<idle>-0 1d.h5 1us+: 0:120:R + [001] 12: 0:R watchdog/1
<idle>-0 1d.h5 3us : ttwu_do_activate.clone.1 <-try_to_wake_up
Link: http://lkml.kernel.org/r/20111107150849.GE1807@m.brq.redhat.com
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@redhat.com>
Signed-off-by: Jiri Olsa <jolsa@redhat.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2011-11-07 22:08:49 +07:00
|
|
|
void trace_latency_header(struct seq_file *m);
|
2010-04-03 00:01:22 +07:00
|
|
|
void trace_default_header(struct seq_file *m);
|
|
|
|
void print_trace_header(struct seq_file *m, struct trace_iterator *iter);
|
|
|
|
int trace_empty(struct trace_iterator *iter);
|
2008-05-13 02:20:42 +07:00
|
|
|
|
2008-11-26 06:57:25 +07:00
|
|
|
void trace_graph_return(struct ftrace_graph_ret *trace);
|
2008-12-03 11:50:05 +07:00
|
|
|
int trace_graph_entry(struct ftrace_graph_ent *trace);
|
2009-07-29 23:59:58 +07:00
|
|
|
void set_graph_array(struct trace_array *tr);
|
2008-11-25 15:24:15 +07:00
|
|
|
|
2008-05-22 22:49:22 +07:00
|
|
|
void tracing_start_cmdline_record(void);
|
|
|
|
void tracing_stop_cmdline_record(void);
|
2008-05-13 02:20:42 +07:00
|
|
|
int register_tracer(struct tracer *type);
|
2009-09-13 06:43:07 +07:00
|
|
|
int is_tracing_stopped(void);
|
2010-08-05 21:22:23 +07:00
|
|
|
|
2013-12-22 05:39:40 +07:00
|
|
|
loff_t tracing_lseek(struct file *file, loff_t offset, int whence);
|
|
|
|
|
2010-08-05 21:22:23 +07:00
|
|
|
extern cpumask_var_t __read_mostly tracing_buffer_mask;
|
|
|
|
|
|
|
|
#define for_each_tracing_cpu(cpu) \
|
|
|
|
for_each_cpu(cpu, tracing_buffer_mask)
|
2008-05-13 02:20:42 +07:00
|
|
|
|
|
|
|
extern unsigned long nsecs_to_usecs(unsigned long nsecs);
|
|
|
|
|
2010-02-26 06:36:43 +07:00
|
|
|
extern unsigned long tracing_thresh;
|
|
|
|
|
2016-04-14 18:38:13 +07:00
|
|
|
/* PID filtering */
|
2016-04-21 22:35:30 +07:00
|
|
|
|
|
|
|
extern int pid_max;
|
|
|
|
|
2016-04-14 18:38:13 +07:00
|
|
|
bool trace_find_filtered_pid(struct trace_pid_list *filtered_pids,
|
|
|
|
pid_t search_pid);
|
|
|
|
bool trace_ignore_this_task(struct trace_pid_list *filtered_pids,
|
|
|
|
struct task_struct *task);
|
|
|
|
void trace_filter_add_remove_task(struct trace_pid_list *pid_list,
|
|
|
|
struct task_struct *self,
|
|
|
|
struct task_struct *task);
|
2016-04-21 02:19:54 +07:00
|
|
|
void *trace_pid_next(struct trace_pid_list *pid_list, void *v, loff_t *pos);
|
|
|
|
void *trace_pid_start(struct trace_pid_list *pid_list, loff_t *pos);
|
|
|
|
int trace_pid_show(struct seq_file *m, void *v);
|
2016-04-21 22:35:30 +07:00
|
|
|
void trace_free_pid_list(struct trace_pid_list *pid_list);
|
|
|
|
int trace_pid_write(struct trace_pid_list *filtered_pids,
|
|
|
|
struct trace_pid_list **new_pid_list,
|
|
|
|
const char __user *ubuf, size_t cnt);
|
2016-04-14 18:38:13 +07:00
|
|
|
|
2009-08-28 03:52:21 +07:00
|
|
|
#ifdef CONFIG_TRACER_MAX_TRACE
|
2008-05-13 02:20:42 +07:00
|
|
|
void update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu);
|
|
|
|
void update_max_tr_single(struct trace_array *tr,
|
|
|
|
struct task_struct *tsk, int cpu);
|
2009-08-28 03:52:21 +07:00
|
|
|
#endif /* CONFIG_TRACER_MAX_TRACE */
|
2008-05-13 02:20:42 +07:00
|
|
|
|
2009-07-29 22:51:13 +07:00
|
|
|
#ifdef CONFIG_STACKTRACE
|
2009-09-03 01:17:06 +07:00
|
|
|
void ftrace_trace_userstack(struct ring_buffer *buffer, unsigned long flags,
|
2009-07-29 22:51:13 +07:00
|
|
|
int pc);
|
|
|
|
|
|
|
|
void __trace_stack(struct trace_array *tr, unsigned long flags, int skip,
|
|
|
|
int pc);
|
|
|
|
#else
|
2010-05-10 10:23:00 +07:00
|
|
|
static inline void ftrace_trace_userstack(struct ring_buffer *buffer,
|
2009-07-29 22:51:13 +07:00
|
|
|
unsigned long flags, int pc)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void __trace_stack(struct trace_array *tr, unsigned long flags,
|
|
|
|
int skip, int pc)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_STACKTRACE */
|
2009-01-16 07:12:40 +07:00
|
|
|
|
2016-12-22 02:32:01 +07:00
|
|
|
extern u64 ftrace_now(int cpu);
|
2008-05-13 02:20:42 +07:00
|
|
|
|
2009-03-17 06:20:15 +07:00
|
|
|
extern void trace_find_cmdline(int pid, char comm[]);
|
2016-04-14 03:59:18 +07:00
|
|
|
extern void trace_event_follow_fork(struct trace_array *tr, bool enable);
|
2008-12-29 19:02:17 +07:00
|
|
|
|
2008-05-13 02:20:42 +07:00
|
|
|
#ifdef CONFIG_DYNAMIC_FTRACE
|
|
|
|
extern unsigned long ftrace_update_tot_cnt;
|
2012-07-21 00:45:59 +07:00
|
|
|
#endif
|
2008-05-13 02:20:54 +07:00
|
|
|
#define DYN_FTRACE_TEST_NAME trace_selftest_dynamic_test_func
|
|
|
|
extern int DYN_FTRACE_TEST_NAME(void);
|
2011-05-06 11:08:51 +07:00
|
|
|
#define DYN_FTRACE_TEST_NAME2 trace_selftest_dynamic_test_func2
|
|
|
|
extern int DYN_FTRACE_TEST_NAME2(void);
|
2008-05-13 02:20:42 +07:00
|
|
|
|
2013-03-08 10:48:09 +07:00
|
|
|
extern bool ring_buffer_expanded;
|
2009-07-01 09:47:05 +07:00
|
|
|
extern bool tracing_selftest_disabled;
|
|
|
|
|
2008-05-13 02:20:44 +07:00
|
|
|
#ifdef CONFIG_FTRACE_STARTUP_TEST
|
|
|
|
extern int trace_selftest_startup_function(struct tracer *trace,
|
|
|
|
struct trace_array *tr);
|
2009-02-08 03:33:57 +07:00
|
|
|
extern int trace_selftest_startup_function_graph(struct tracer *trace,
|
|
|
|
struct trace_array *tr);
|
2008-05-13 02:20:44 +07:00
|
|
|
extern int trace_selftest_startup_irqsoff(struct tracer *trace,
|
|
|
|
struct trace_array *tr);
|
|
|
|
extern int trace_selftest_startup_preemptoff(struct tracer *trace,
|
|
|
|
struct trace_array *tr);
|
|
|
|
extern int trace_selftest_startup_preemptirqsoff(struct tracer *trace,
|
|
|
|
struct trace_array *tr);
|
|
|
|
extern int trace_selftest_startup_wakeup(struct tracer *trace,
|
|
|
|
struct trace_array *tr);
|
2008-09-19 17:06:43 +07:00
|
|
|
extern int trace_selftest_startup_nop(struct tracer *trace,
|
|
|
|
struct trace_array *tr);
|
2008-05-13 02:20:44 +07:00
|
|
|
extern int trace_selftest_startup_sched_switch(struct tracer *trace,
|
|
|
|
struct trace_array *tr);
|
2008-11-13 03:24:24 +07:00
|
|
|
extern int trace_selftest_startup_branch(struct tracer *trace,
|
|
|
|
struct trace_array *tr);
|
2013-07-19 01:41:51 +07:00
|
|
|
/*
|
|
|
|
* Tracer data references selftest functions that only occur
|
|
|
|
* on boot up. These can be __init functions. Thus, when selftests
|
|
|
|
* are enabled, then the tracers need to reference __init functions.
|
|
|
|
*/
|
|
|
|
#define __tracer_data __refdata
|
|
|
|
#else
|
|
|
|
/* Tracers are seldom changed. Optimize when selftests are disabled. */
|
|
|
|
#define __tracer_data __read_mostly
|
2008-05-13 02:20:44 +07:00
|
|
|
#endif /* CONFIG_FTRACE_STARTUP_TEST */
|
|
|
|
|
2008-05-13 02:20:45 +07:00
|
|
|
extern void *head_page(struct trace_array_cpu *data);
|
2016-12-22 02:32:01 +07:00
|
|
|
extern unsigned long long ns2usecs(u64 nsec);
|
2008-12-04 05:45:11 +07:00
|
|
|
extern int
|
2009-03-20 01:03:53 +07:00
|
|
|
trace_vbprintk(unsigned long ip, const char *fmt, va_list args);
|
2009-03-13 00:24:49 +07:00
|
|
|
extern int
|
2009-03-20 01:03:53 +07:00
|
|
|
trace_vprintk(unsigned long ip, const char *fmt, va_list args);
|
2009-09-04 06:11:07 +07:00
|
|
|
extern int
|
|
|
|
trace_array_vprintk(struct trace_array *tr,
|
|
|
|
unsigned long ip, const char *fmt, va_list args);
|
|
|
|
int trace_array_printk(struct trace_array *tr,
|
|
|
|
unsigned long ip, const char *fmt, ...);
|
tracing: Consolidate max_tr into main trace_array structure
Currently, the way the latency tracers and snapshot feature works
is to have a separate trace_array called "max_tr" that holds the
snapshot buffer. For latency tracers, this snapshot buffer is used
to swap the running buffer with this buffer to save the current max
latency.
The only items needed for the max_tr is really just a copy of the buffer
itself, the per_cpu data pointers, the time_start timestamp that states
when the max latency was triggered, and the cpu that the max latency
was triggered on. All other fields in trace_array are unused by the
max_tr, making the max_tr mostly bloat.
This change removes the max_tr completely, and adds a new structure
called trace_buffer, that holds the buffer pointer, the per_cpu data
pointers, the time_start timestamp, and the cpu where the latency occurred.
The trace_array, now has two trace_buffers, one for the normal trace and
one for the max trace or snapshot. By doing this, not only do we remove
the bloat from the max_trace but the instances of traces can now use
their own snapshot feature and not have just the top level global_trace have
the snapshot feature and latency tracers for itself.
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-03-05 21:24:35 +07:00
|
|
|
int trace_array_printk_buf(struct ring_buffer *buffer,
|
|
|
|
unsigned long ip, const char *fmt, ...);
|
2010-08-05 21:22:23 +07:00
|
|
|
void trace_printk_seq(struct trace_seq *s);
|
|
|
|
enum print_line_t print_trace_line(struct trace_iterator *iter);
|
2008-05-13 02:20:45 +07:00
|
|
|
|
2014-11-24 07:34:19 +07:00
|
|
|
extern char trace_find_mark(unsigned long long duration);
|
|
|
|
|
2017-01-20 09:44:46 +07:00
|
|
|
struct ftrace_hash {
|
|
|
|
unsigned long size_bits;
|
|
|
|
struct hlist_head *buckets;
|
|
|
|
unsigned long count;
|
|
|
|
struct rcu_head rcu;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ftrace_func_entry *
|
|
|
|
ftrace_lookup_ip(struct ftrace_hash *hash, unsigned long ip);
|
|
|
|
|
2017-01-23 19:24:45 +07:00
|
|
|
static __always_inline bool ftrace_hash_empty(struct ftrace_hash *hash)
|
2017-01-20 09:44:46 +07:00
|
|
|
{
|
|
|
|
return !hash || !hash->count;
|
|
|
|
}
|
|
|
|
|
2008-11-11 13:14:25 +07:00
|
|
|
/* Standard output formatting function used for function return traces */
|
2008-11-26 03:07:04 +07:00
|
|
|
#ifdef CONFIG_FUNCTION_GRAPH_TRACER
|
2010-04-03 00:01:22 +07:00
|
|
|
|
|
|
|
/* Flag options */
|
|
|
|
#define TRACE_GRAPH_PRINT_OVERRUN 0x1
|
|
|
|
#define TRACE_GRAPH_PRINT_CPU 0x2
|
|
|
|
#define TRACE_GRAPH_PRINT_OVERHEAD 0x4
|
|
|
|
#define TRACE_GRAPH_PRINT_PROC 0x8
|
|
|
|
#define TRACE_GRAPH_PRINT_DURATION 0x10
|
|
|
|
#define TRACE_GRAPH_PRINT_ABS_TIME 0x20
|
2014-05-21 05:10:36 +07:00
|
|
|
#define TRACE_GRAPH_PRINT_IRQS 0x40
|
2014-05-21 05:10:51 +07:00
|
|
|
#define TRACE_GRAPH_PRINT_TAIL 0x80
|
2015-09-30 06:06:50 +07:00
|
|
|
#define TRACE_GRAPH_SLEEP_TIME 0x100
|
|
|
|
#define TRACE_GRAPH_GRAPH_TIME 0x200
|
2013-11-07 02:50:06 +07:00
|
|
|
#define TRACE_GRAPH_PRINT_FILL_SHIFT 28
|
|
|
|
#define TRACE_GRAPH_PRINT_FILL_MASK (0x3 << TRACE_GRAPH_PRINT_FILL_SHIFT)
|
2010-04-03 00:01:22 +07:00
|
|
|
|
2015-09-30 06:06:50 +07:00
|
|
|
extern void ftrace_graph_sleep_time_control(bool enable);
|
|
|
|
extern void ftrace_graph_graph_time_control(bool enable);
|
|
|
|
|
2010-04-03 00:01:21 +07:00
|
|
|
extern enum print_line_t
|
|
|
|
print_graph_function_flags(struct trace_iterator *iter, u32 flags);
|
|
|
|
extern void print_graph_headers_flags(struct seq_file *s, u32 flags);
|
2014-11-13 02:57:38 +07:00
|
|
|
extern void
|
2009-03-24 10:12:58 +07:00
|
|
|
trace_print_graph_duration(unsigned long long duration, struct trace_seq *s);
|
2010-04-03 00:01:22 +07:00
|
|
|
extern void graph_trace_open(struct trace_iterator *iter);
|
|
|
|
extern void graph_trace_close(struct trace_iterator *iter);
|
|
|
|
extern int __trace_graph_entry(struct trace_array *tr,
|
|
|
|
struct ftrace_graph_ent *trace,
|
|
|
|
unsigned long flags, int pc);
|
|
|
|
extern void __trace_graph_return(struct trace_array *tr,
|
|
|
|
struct ftrace_graph_ret *trace,
|
|
|
|
unsigned long flags, int pc);
|
|
|
|
|
2008-12-04 03:36:57 +07:00
|
|
|
#ifdef CONFIG_DYNAMIC_FTRACE
|
2017-01-20 09:44:47 +07:00
|
|
|
extern struct ftrace_hash *ftrace_graph_hash;
|
|
|
|
extern struct ftrace_hash *ftrace_graph_notrace_hash;
|
2008-12-04 03:36:57 +07:00
|
|
|
|
|
|
|
static inline int ftrace_graph_addr(unsigned long addr)
|
|
|
|
{
|
2017-01-20 09:44:47 +07:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
preempt_disable_notrace();
|
|
|
|
|
|
|
|
if (ftrace_hash_empty(ftrace_graph_hash)) {
|
|
|
|
ret = 1;
|
|
|
|
goto out;
|
2008-12-04 03:36:57 +07:00
|
|
|
}
|
|
|
|
|
2017-01-20 09:44:47 +07:00
|
|
|
if (ftrace_lookup_ip(ftrace_graph_hash, addr)) {
|
|
|
|
/*
|
|
|
|
* If no irqs are to be traced, but a set_graph_function
|
|
|
|
* is set, and called by an interrupt handler, we still
|
|
|
|
* want to trace it.
|
|
|
|
*/
|
|
|
|
if (in_irq())
|
|
|
|
trace_recursion_set(TRACE_IRQ_BIT);
|
|
|
|
else
|
|
|
|
trace_recursion_clear(TRACE_IRQ_BIT);
|
|
|
|
ret = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
preempt_enable_notrace();
|
|
|
|
return ret;
|
2008-12-04 03:36:57 +07:00
|
|
|
}
|
2013-10-14 15:24:26 +07:00
|
|
|
|
|
|
|
static inline int ftrace_graph_notrace_addr(unsigned long addr)
|
|
|
|
{
|
2017-01-20 09:44:47 +07:00
|
|
|
int ret = 0;
|
2013-10-14 15:24:26 +07:00
|
|
|
|
2017-01-20 09:44:47 +07:00
|
|
|
preempt_disable_notrace();
|
2013-10-14 15:24:26 +07:00
|
|
|
|
2017-01-20 09:44:47 +07:00
|
|
|
if (ftrace_lookup_ip(ftrace_graph_notrace_hash, addr))
|
|
|
|
ret = 1;
|
2013-10-14 15:24:26 +07:00
|
|
|
|
2017-01-20 09:44:47 +07:00
|
|
|
preempt_enable_notrace();
|
|
|
|
return ret;
|
2013-10-14 15:24:26 +07:00
|
|
|
}
|
2008-11-11 13:14:25 +07:00
|
|
|
#else
|
2008-12-04 15:18:28 +07:00
|
|
|
static inline int ftrace_graph_addr(unsigned long addr)
|
|
|
|
{
|
|
|
|
return 1;
|
2008-12-04 03:36:57 +07:00
|
|
|
}
|
2013-10-14 15:24:26 +07:00
|
|
|
|
|
|
|
static inline int ftrace_graph_notrace_addr(unsigned long addr)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2008-12-04 03:36:57 +07:00
|
|
|
#endif /* CONFIG_DYNAMIC_FTRACE */
|
2016-12-09 07:28:28 +07:00
|
|
|
|
|
|
|
extern unsigned int fgraph_max_depth;
|
|
|
|
|
|
|
|
static inline bool ftrace_graph_ignore_func(struct ftrace_graph_ent *trace)
|
|
|
|
{
|
|
|
|
/* trace it when it is-nested-in or is a function enabled. */
|
|
|
|
return !(trace->depth || ftrace_graph_addr(trace->func)) ||
|
|
|
|
(trace->depth < 0) ||
|
|
|
|
(fgraph_max_depth && trace->depth >= fgraph_max_depth);
|
|
|
|
}
|
|
|
|
|
2008-12-04 03:36:57 +07:00
|
|
|
#else /* CONFIG_FUNCTION_GRAPH_TRACER */
|
2008-11-11 13:14:25 +07:00
|
|
|
static inline enum print_line_t
|
2010-04-03 00:01:21 +07:00
|
|
|
print_graph_function_flags(struct trace_iterator *iter, u32 flags)
|
2008-11-11 13:14:25 +07:00
|
|
|
{
|
|
|
|
return TRACE_TYPE_UNHANDLED;
|
|
|
|
}
|
2008-12-04 03:36:57 +07:00
|
|
|
#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
|
2008-11-11 13:14:25 +07:00
|
|
|
|
2009-10-14 03:33:52 +07:00
|
|
|
extern struct list_head ftrace_pids;
|
2008-12-04 03:36:59 +07:00
|
|
|
|
2009-06-25 12:30:12 +07:00
|
|
|
#ifdef CONFIG_FUNCTION_TRACER
|
2017-04-01 06:21:41 +07:00
|
|
|
struct ftrace_func_command {
|
|
|
|
struct list_head list;
|
|
|
|
char *name;
|
|
|
|
int (*func)(struct ftrace_hash *hash,
|
|
|
|
char *func, char *cmd,
|
|
|
|
char *params, int enable);
|
|
|
|
};
|
2013-06-28 09:18:06 +07:00
|
|
|
extern bool ftrace_filter_param __initdata;
|
2016-04-23 05:11:33 +07:00
|
|
|
static inline int ftrace_trace_task(struct trace_array *tr)
|
2008-12-04 03:36:59 +07:00
|
|
|
{
|
2016-04-23 05:11:33 +07:00
|
|
|
return !this_cpu_read(tr->trace_buffer.data->ftrace_ignore_pid);
|
2008-12-04 03:36:59 +07:00
|
|
|
}
|
2011-09-30 08:26:16 +07:00
|
|
|
extern int ftrace_is_dead(void);
|
2014-01-11 04:17:45 +07:00
|
|
|
int ftrace_create_function_files(struct trace_array *tr,
|
|
|
|
struct dentry *parent);
|
|
|
|
void ftrace_destroy_function_files(struct trace_array *tr);
|
2014-01-11 05:01:58 +07:00
|
|
|
void ftrace_init_global_array_ops(struct trace_array *tr);
|
|
|
|
void ftrace_init_array_ops(struct trace_array *tr, ftrace_func_t func);
|
|
|
|
void ftrace_reset_array_ops(struct trace_array *tr);
|
2014-04-20 22:10:43 +07:00
|
|
|
int using_ftrace_ops_list_func(void);
|
2016-04-23 05:11:33 +07:00
|
|
|
void ftrace_init_tracefs(struct trace_array *tr, struct dentry *d_tracer);
|
2016-07-05 21:04:34 +07:00
|
|
|
void ftrace_init_tracefs_toplevel(struct trace_array *tr,
|
|
|
|
struct dentry *d_tracer);
|
2017-03-04 01:48:42 +07:00
|
|
|
int init_function_trace(void);
|
2017-04-17 09:44:28 +07:00
|
|
|
void ftrace_pid_follow_fork(struct trace_array *tr, bool enable);
|
2009-06-25 12:30:12 +07:00
|
|
|
#else
|
2016-04-23 05:11:33 +07:00
|
|
|
static inline int ftrace_trace_task(struct trace_array *tr)
|
2009-06-25 12:30:12 +07:00
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
2011-09-30 08:26:16 +07:00
|
|
|
static inline int ftrace_is_dead(void) { return 0; }
|
2014-01-11 04:17:45 +07:00
|
|
|
static inline int
|
|
|
|
ftrace_create_function_files(struct trace_array *tr,
|
|
|
|
struct dentry *parent)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
static inline void ftrace_destroy_function_files(struct trace_array *tr) { }
|
2014-01-11 05:01:58 +07:00
|
|
|
static inline __init void
|
|
|
|
ftrace_init_global_array_ops(struct trace_array *tr) { }
|
|
|
|
static inline void ftrace_reset_array_ops(struct trace_array *tr) { }
|
2016-04-23 05:11:33 +07:00
|
|
|
static inline void ftrace_init_tracefs(struct trace_array *tr, struct dentry *d) { }
|
2016-07-05 21:04:34 +07:00
|
|
|
static inline void ftrace_init_tracefs_toplevel(struct trace_array *tr, struct dentry *d) { }
|
2017-03-04 01:48:42 +07:00
|
|
|
static inline int init_function_trace(void) { return 0; }
|
2017-04-17 09:44:28 +07:00
|
|
|
static inline void ftrace_pid_follow_fork(struct trace_array *tr, bool enable) { }
|
2014-01-11 05:01:58 +07:00
|
|
|
/* ftace_func_t type is not defined, use macro instead of static inline */
|
|
|
|
#define ftrace_init_array_ops(tr, func) do { } while (0)
|
2014-01-11 04:17:45 +07:00
|
|
|
#endif /* CONFIG_FUNCTION_TRACER */
|
|
|
|
|
|
|
|
#if defined(CONFIG_FUNCTION_TRACER) && defined(CONFIG_DYNAMIC_FTRACE)
|
2017-04-01 06:01:14 +07:00
|
|
|
|
|
|
|
struct ftrace_probe_ops {
|
2017-04-05 05:16:29 +07:00
|
|
|
struct ftrace_ops ops;
|
2017-04-05 08:31:28 +07:00
|
|
|
struct list_head list;
|
2017-04-01 06:01:14 +07:00
|
|
|
void (*func)(unsigned long ip,
|
|
|
|
unsigned long parent_ip,
|
2017-04-04 05:18:47 +07:00
|
|
|
struct ftrace_probe_ops *ops,
|
2017-04-01 06:01:14 +07:00
|
|
|
void **data);
|
|
|
|
int (*init)(struct ftrace_probe_ops *ops,
|
2017-04-04 21:27:51 +07:00
|
|
|
unsigned long ip, void *data);
|
2017-04-01 06:01:14 +07:00
|
|
|
void (*free)(struct ftrace_probe_ops *ops,
|
|
|
|
unsigned long ip, void **data);
|
|
|
|
int (*print)(struct seq_file *m,
|
|
|
|
unsigned long ip,
|
|
|
|
struct ftrace_probe_ops *ops,
|
|
|
|
void *data);
|
2017-04-04 07:58:35 +07:00
|
|
|
void *private_data;
|
2017-04-01 06:01:14 +07:00
|
|
|
};
|
|
|
|
|
2017-04-04 07:58:35 +07:00
|
|
|
struct ftrace_func_mapper;
|
|
|
|
typedef int (*ftrace_mapper_func)(void *data);
|
|
|
|
|
|
|
|
struct ftrace_func_mapper *allocate_ftrace_func_mapper(void);
|
|
|
|
void **ftrace_func_mapper_find_ip(struct ftrace_func_mapper *mapper,
|
|
|
|
unsigned long ip);
|
|
|
|
int ftrace_func_mapper_add_ip(struct ftrace_func_mapper *mapper,
|
|
|
|
unsigned long ip, void *data);
|
|
|
|
void *ftrace_func_mapper_remove_ip(struct ftrace_func_mapper *mapper,
|
|
|
|
unsigned long ip);
|
|
|
|
void free_ftrace_func_mapper(struct ftrace_func_mapper *mapper,
|
|
|
|
ftrace_mapper_func free_func);
|
|
|
|
|
2017-04-01 06:01:14 +07:00
|
|
|
extern int
|
|
|
|
register_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
|
|
|
|
void *data);
|
2017-04-05 03:44:43 +07:00
|
|
|
extern int
|
2017-04-01 06:01:14 +07:00
|
|
|
unregister_ftrace_function_probe_func(char *glob, struct ftrace_probe_ops *ops);
|
|
|
|
|
2017-04-01 06:21:41 +07:00
|
|
|
int register_ftrace_command(struct ftrace_func_command *cmd);
|
|
|
|
int unregister_ftrace_command(struct ftrace_func_command *cmd);
|
|
|
|
|
2014-01-11 04:17:45 +07:00
|
|
|
void ftrace_create_filter_files(struct ftrace_ops *ops,
|
|
|
|
struct dentry *parent);
|
|
|
|
void ftrace_destroy_filter_files(struct ftrace_ops *ops);
|
|
|
|
#else
|
2017-04-01 06:21:41 +07:00
|
|
|
struct ftrace_func_command;
|
|
|
|
|
|
|
|
static inline __init int register_ftrace_command(struct ftrace_func_command *cmd)
|
|
|
|
{
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
static inline __init int unregister_ftrace_command(char *cmd_name)
|
|
|
|
{
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2014-01-11 04:17:45 +07:00
|
|
|
/*
|
|
|
|
* The ops parameter passed in is usually undefined.
|
|
|
|
* This must be a macro.
|
|
|
|
*/
|
|
|
|
#define ftrace_create_filter_files(ops, parent) do { } while (0)
|
|
|
|
#define ftrace_destroy_filter_files(ops) do { } while (0)
|
|
|
|
#endif /* CONFIG_FUNCTION_TRACER && CONFIG_DYNAMIC_FTRACE */
|
2008-12-04 03:36:59 +07:00
|
|
|
|
2015-09-29 21:43:36 +07:00
|
|
|
bool ftrace_event_is_function(struct trace_event_call *call);
|
2012-02-15 21:51:52 +07:00
|
|
|
|
2009-09-11 22:29:27 +07:00
|
|
|
/*
|
|
|
|
* struct trace_parser - servers for reading the user input separated by spaces
|
|
|
|
* @cont: set if the input is not complete - no final space char was found
|
|
|
|
* @buffer: holds the parsed user input
|
2010-01-29 14:57:49 +07:00
|
|
|
* @idx: user input length
|
2009-09-11 22:29:27 +07:00
|
|
|
* @size: buffer size
|
|
|
|
*/
|
|
|
|
struct trace_parser {
|
|
|
|
bool cont;
|
|
|
|
char *buffer;
|
|
|
|
unsigned idx;
|
|
|
|
unsigned size;
|
|
|
|
};
|
|
|
|
|
|
|
|
static inline bool trace_parser_loaded(struct trace_parser *parser)
|
|
|
|
{
|
|
|
|
return (parser->idx != 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool trace_parser_cont(struct trace_parser *parser)
|
|
|
|
{
|
|
|
|
return parser->cont;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void trace_parser_clear(struct trace_parser *parser)
|
|
|
|
{
|
|
|
|
parser->cont = false;
|
|
|
|
parser->idx = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
extern int trace_parser_get_init(struct trace_parser *parser, int size);
|
|
|
|
extern void trace_parser_put(struct trace_parser *parser);
|
|
|
|
extern int trace_get_user(struct trace_parser *parser, const char __user *ubuf,
|
|
|
|
size_t cnt, loff_t *ppos);
|
|
|
|
|
2015-09-29 21:15:10 +07:00
|
|
|
/*
|
|
|
|
* Only create function graph options if function graph is configured.
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_FUNCTION_GRAPH_TRACER
|
|
|
|
# define FGRAPH_FLAGS \
|
|
|
|
C(DISPLAY_GRAPH, "display-graph"),
|
|
|
|
#else
|
|
|
|
# define FGRAPH_FLAGS
|
|
|
|
#endif
|
|
|
|
|
2015-09-29 21:19:35 +07:00
|
|
|
#ifdef CONFIG_BRANCH_TRACER
|
|
|
|
# define BRANCH_FLAGS \
|
|
|
|
C(BRANCH, "branch"),
|
|
|
|
#else
|
|
|
|
# define BRANCH_FLAGS
|
|
|
|
#endif
|
|
|
|
|
2015-09-29 21:24:56 +07:00
|
|
|
#ifdef CONFIG_FUNCTION_TRACER
|
|
|
|
# define FUNCTION_FLAGS \
|
2017-04-17 09:44:28 +07:00
|
|
|
C(FUNCTION, "function-trace"), \
|
|
|
|
C(FUNC_FORK, "function-fork"),
|
2015-09-29 21:24:56 +07:00
|
|
|
# define FUNCTION_DEFAULT_FLAGS TRACE_ITER_FUNCTION
|
|
|
|
#else
|
|
|
|
# define FUNCTION_FLAGS
|
|
|
|
# define FUNCTION_DEFAULT_FLAGS 0UL
|
2017-04-17 09:44:28 +07:00
|
|
|
# define TRACE_ITER_FUNC_FORK 0UL
|
2015-09-29 21:24:56 +07:00
|
|
|
#endif
|
|
|
|
|
2015-09-30 02:38:55 +07:00
|
|
|
#ifdef CONFIG_STACKTRACE
|
|
|
|
# define STACK_FLAGS \
|
|
|
|
C(STACKTRACE, "stacktrace"),
|
|
|
|
#else
|
|
|
|
# define STACK_FLAGS
|
|
|
|
#endif
|
|
|
|
|
2008-05-13 02:21:00 +07:00
|
|
|
/*
|
|
|
|
* trace_iterator_flags is an enumeration that defines bit
|
|
|
|
* positions into trace_flags that controls the output.
|
|
|
|
*
|
|
|
|
* NOTE: These bits must match the trace_options array in
|
tracing: Use TRACE_FLAGS macro to keep enums and strings matched
Use a cute little macro trick to keep the names of the trace flags file
guaranteed to match the corresponding masks.
The macro TRACE_FLAGS is defined as a serious of enum names followed by
the string name of the file that matches it. For example:
#define TRACE_FLAGS \
C(PRINT_PARENT, "print-parent"), \
C(SYM_OFFSET, "sym-offset"), \
C(SYM_ADDR, "sym-addr"), \
C(VERBOSE, "verbose"),
Now we can define the following:
#undef C
#define C(a, b) TRACE_ITER_##a##_BIT
enum trace_iterator_bits { TRACE_FLAGS };
The above creates:
enum trace_iterator_bits {
TRACE_ITER_PRINT_PARENT_BIT,
TRACE_ITER_SYM_OFFSET_BIT,
TRACE_ITER_SYM_ADDR_BIT,
TRACE_ITER_VERBOSE_BIT,
};
Then we can redefine C as:
#undef C
#define C(a, b) TRACE_ITER_##a = (1 << TRACE_ITER_##a##_BIT)
enum trace_iterator_flags { TRACE_FLAGS };
Which creates:
enum trace_iterator_flags {
TRACE_ITER_PRINT_PARENT = (1 << TRACE_ITER_PRINT_PARENT_BIT),
TRACE_ITER_SYM_OFFSET = (1 << TRACE_ITER_SYM_OFFSET_BIT),
TRACE_ITER_SYM_ADDR = (1 << TRACE_ITER_SYM_ADDR_BIT),
TRACE_ITER_VERBOSE = (1 << TRACE_ITER_VERBOSE_BIT),
};
Then finally we can create the list of file names:
#undef C
#define C(a, b) b
static const char *trace_options[] = {
TRACE_FLAGS
NULL
};
Which creates:
static const char *trace_options[] = {
"print-parent",
"sym-offset",
"sym-addr",
"verbose",
NULL
};
The importance of this is that the strings match the bit index.
trace_options[TRACE_ITER_SYM_ADDR_BIT] == "sym-addr"
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2015-09-29 20:43:30 +07:00
|
|
|
* trace.c (this macro guarantees it).
|
2008-05-13 02:21:00 +07:00
|
|
|
*/
|
tracing: Use TRACE_FLAGS macro to keep enums and strings matched
Use a cute little macro trick to keep the names of the trace flags file
guaranteed to match the corresponding masks.
The macro TRACE_FLAGS is defined as a serious of enum names followed by
the string name of the file that matches it. For example:
#define TRACE_FLAGS \
C(PRINT_PARENT, "print-parent"), \
C(SYM_OFFSET, "sym-offset"), \
C(SYM_ADDR, "sym-addr"), \
C(VERBOSE, "verbose"),
Now we can define the following:
#undef C
#define C(a, b) TRACE_ITER_##a##_BIT
enum trace_iterator_bits { TRACE_FLAGS };
The above creates:
enum trace_iterator_bits {
TRACE_ITER_PRINT_PARENT_BIT,
TRACE_ITER_SYM_OFFSET_BIT,
TRACE_ITER_SYM_ADDR_BIT,
TRACE_ITER_VERBOSE_BIT,
};
Then we can redefine C as:
#undef C
#define C(a, b) TRACE_ITER_##a = (1 << TRACE_ITER_##a##_BIT)
enum trace_iterator_flags { TRACE_FLAGS };
Which creates:
enum trace_iterator_flags {
TRACE_ITER_PRINT_PARENT = (1 << TRACE_ITER_PRINT_PARENT_BIT),
TRACE_ITER_SYM_OFFSET = (1 << TRACE_ITER_SYM_OFFSET_BIT),
TRACE_ITER_SYM_ADDR = (1 << TRACE_ITER_SYM_ADDR_BIT),
TRACE_ITER_VERBOSE = (1 << TRACE_ITER_VERBOSE_BIT),
};
Then finally we can create the list of file names:
#undef C
#define C(a, b) b
static const char *trace_options[] = {
TRACE_FLAGS
NULL
};
Which creates:
static const char *trace_options[] = {
"print-parent",
"sym-offset",
"sym-addr",
"verbose",
NULL
};
The importance of this is that the strings match the bit index.
trace_options[TRACE_ITER_SYM_ADDR_BIT] == "sym-addr"
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2015-09-29 20:43:30 +07:00
|
|
|
#define TRACE_FLAGS \
|
|
|
|
C(PRINT_PARENT, "print-parent"), \
|
|
|
|
C(SYM_OFFSET, "sym-offset"), \
|
|
|
|
C(SYM_ADDR, "sym-addr"), \
|
|
|
|
C(VERBOSE, "verbose"), \
|
|
|
|
C(RAW, "raw"), \
|
|
|
|
C(HEX, "hex"), \
|
|
|
|
C(BIN, "bin"), \
|
|
|
|
C(BLOCK, "block"), \
|
|
|
|
C(PRINTK, "trace_printk"), \
|
|
|
|
C(ANNOTATE, "annotate"), \
|
|
|
|
C(USERSTACKTRACE, "userstacktrace"), \
|
|
|
|
C(SYM_USEROBJ, "sym-userobj"), \
|
|
|
|
C(PRINTK_MSGONLY, "printk-msg-only"), \
|
|
|
|
C(CONTEXT_INFO, "context-info"), /* Print pid/cpu/time */ \
|
|
|
|
C(LATENCY_FMT, "latency-format"), \
|
|
|
|
C(RECORD_CMD, "record-cmd"), \
|
|
|
|
C(OVERWRITE, "overwrite"), \
|
|
|
|
C(STOP_ON_FREE, "disable_on_free"), \
|
|
|
|
C(IRQ_INFO, "irq-info"), \
|
|
|
|
C(MARKERS, "markers"), \
|
2016-04-14 03:59:18 +07:00
|
|
|
C(EVENT_FORK, "event-fork"), \
|
2015-09-29 21:24:56 +07:00
|
|
|
FUNCTION_FLAGS \
|
2015-09-29 21:19:35 +07:00
|
|
|
FGRAPH_FLAGS \
|
2015-09-30 02:38:55 +07:00
|
|
|
STACK_FLAGS \
|
2015-09-29 21:19:35 +07:00
|
|
|
BRANCH_FLAGS
|
2015-09-29 20:22:05 +07:00
|
|
|
|
tracing: Use TRACE_FLAGS macro to keep enums and strings matched
Use a cute little macro trick to keep the names of the trace flags file
guaranteed to match the corresponding masks.
The macro TRACE_FLAGS is defined as a serious of enum names followed by
the string name of the file that matches it. For example:
#define TRACE_FLAGS \
C(PRINT_PARENT, "print-parent"), \
C(SYM_OFFSET, "sym-offset"), \
C(SYM_ADDR, "sym-addr"), \
C(VERBOSE, "verbose"),
Now we can define the following:
#undef C
#define C(a, b) TRACE_ITER_##a##_BIT
enum trace_iterator_bits { TRACE_FLAGS };
The above creates:
enum trace_iterator_bits {
TRACE_ITER_PRINT_PARENT_BIT,
TRACE_ITER_SYM_OFFSET_BIT,
TRACE_ITER_SYM_ADDR_BIT,
TRACE_ITER_VERBOSE_BIT,
};
Then we can redefine C as:
#undef C
#define C(a, b) TRACE_ITER_##a = (1 << TRACE_ITER_##a##_BIT)
enum trace_iterator_flags { TRACE_FLAGS };
Which creates:
enum trace_iterator_flags {
TRACE_ITER_PRINT_PARENT = (1 << TRACE_ITER_PRINT_PARENT_BIT),
TRACE_ITER_SYM_OFFSET = (1 << TRACE_ITER_SYM_OFFSET_BIT),
TRACE_ITER_SYM_ADDR = (1 << TRACE_ITER_SYM_ADDR_BIT),
TRACE_ITER_VERBOSE = (1 << TRACE_ITER_VERBOSE_BIT),
};
Then finally we can create the list of file names:
#undef C
#define C(a, b) b
static const char *trace_options[] = {
TRACE_FLAGS
NULL
};
Which creates:
static const char *trace_options[] = {
"print-parent",
"sym-offset",
"sym-addr",
"verbose",
NULL
};
The importance of this is that the strings match the bit index.
trace_options[TRACE_ITER_SYM_ADDR_BIT] == "sym-addr"
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2015-09-29 20:43:30 +07:00
|
|
|
/*
|
|
|
|
* By defining C, we can make TRACE_FLAGS a list of bit names
|
|
|
|
* that will define the bits for the flag masks.
|
|
|
|
*/
|
|
|
|
#undef C
|
|
|
|
#define C(a, b) TRACE_ITER_##a##_BIT
|
|
|
|
|
2015-09-30 05:13:33 +07:00
|
|
|
enum trace_iterator_bits {
|
|
|
|
TRACE_FLAGS
|
|
|
|
/* Make sure we don't go more than we have bits for */
|
|
|
|
TRACE_ITER_LAST_BIT
|
|
|
|
};
|
tracing: Use TRACE_FLAGS macro to keep enums and strings matched
Use a cute little macro trick to keep the names of the trace flags file
guaranteed to match the corresponding masks.
The macro TRACE_FLAGS is defined as a serious of enum names followed by
the string name of the file that matches it. For example:
#define TRACE_FLAGS \
C(PRINT_PARENT, "print-parent"), \
C(SYM_OFFSET, "sym-offset"), \
C(SYM_ADDR, "sym-addr"), \
C(VERBOSE, "verbose"),
Now we can define the following:
#undef C
#define C(a, b) TRACE_ITER_##a##_BIT
enum trace_iterator_bits { TRACE_FLAGS };
The above creates:
enum trace_iterator_bits {
TRACE_ITER_PRINT_PARENT_BIT,
TRACE_ITER_SYM_OFFSET_BIT,
TRACE_ITER_SYM_ADDR_BIT,
TRACE_ITER_VERBOSE_BIT,
};
Then we can redefine C as:
#undef C
#define C(a, b) TRACE_ITER_##a = (1 << TRACE_ITER_##a##_BIT)
enum trace_iterator_flags { TRACE_FLAGS };
Which creates:
enum trace_iterator_flags {
TRACE_ITER_PRINT_PARENT = (1 << TRACE_ITER_PRINT_PARENT_BIT),
TRACE_ITER_SYM_OFFSET = (1 << TRACE_ITER_SYM_OFFSET_BIT),
TRACE_ITER_SYM_ADDR = (1 << TRACE_ITER_SYM_ADDR_BIT),
TRACE_ITER_VERBOSE = (1 << TRACE_ITER_VERBOSE_BIT),
};
Then finally we can create the list of file names:
#undef C
#define C(a, b) b
static const char *trace_options[] = {
TRACE_FLAGS
NULL
};
Which creates:
static const char *trace_options[] = {
"print-parent",
"sym-offset",
"sym-addr",
"verbose",
NULL
};
The importance of this is that the strings match the bit index.
trace_options[TRACE_ITER_SYM_ADDR_BIT] == "sym-addr"
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2015-09-29 20:43:30 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* By redefining C, we can make TRACE_FLAGS a list of masks that
|
|
|
|
* use the bits as defined above.
|
|
|
|
*/
|
|
|
|
#undef C
|
|
|
|
#define C(a, b) TRACE_ITER_##a = (1 << TRACE_ITER_##a##_BIT)
|
|
|
|
|
|
|
|
enum trace_iterator_flags { TRACE_FLAGS };
|
2008-05-13 02:20:52 +07:00
|
|
|
|
2008-11-11 13:14:25 +07:00
|
|
|
/*
|
|
|
|
* TRACE_ITER_SYM_MASK masks the options in trace_flags that
|
|
|
|
* control the output of kernel symbols.
|
|
|
|
*/
|
|
|
|
#define TRACE_ITER_SYM_MASK \
|
|
|
|
(TRACE_ITER_PRINT_PARENT|TRACE_ITER_SYM_OFFSET|TRACE_ITER_SYM_ADDR)
|
|
|
|
|
2008-09-22 01:16:30 +07:00
|
|
|
extern struct tracer nop_trace;
|
|
|
|
|
2008-11-13 03:24:24 +07:00
|
|
|
#ifdef CONFIG_BRANCH_TRACER
|
2008-11-13 03:24:24 +07:00
|
|
|
extern int enable_branch_tracing(struct trace_array *tr);
|
|
|
|
extern void disable_branch_tracing(void);
|
|
|
|
static inline int trace_branch_enable(struct trace_array *tr)
|
2008-11-12 12:14:40 +07:00
|
|
|
{
|
2015-09-30 20:42:05 +07:00
|
|
|
if (tr->trace_flags & TRACE_ITER_BRANCH)
|
2008-11-13 03:24:24 +07:00
|
|
|
return enable_branch_tracing(tr);
|
2008-11-12 12:14:40 +07:00
|
|
|
return 0;
|
|
|
|
}
|
2008-11-13 03:24:24 +07:00
|
|
|
static inline void trace_branch_disable(void)
|
2008-11-12 12:14:40 +07:00
|
|
|
{
|
|
|
|
/* due to races, always disable */
|
2008-11-13 03:24:24 +07:00
|
|
|
disable_branch_tracing();
|
2008-11-12 12:14:40 +07:00
|
|
|
}
|
|
|
|
#else
|
2008-11-13 03:24:24 +07:00
|
|
|
static inline int trace_branch_enable(struct trace_array *tr)
|
2008-11-12 12:14:40 +07:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2008-11-13 03:24:24 +07:00
|
|
|
static inline void trace_branch_disable(void)
|
2008-11-12 12:14:40 +07:00
|
|
|
{
|
|
|
|
}
|
2008-11-13 03:24:24 +07:00
|
|
|
#endif /* CONFIG_BRANCH_TRACER */
|
2008-11-12 12:14:40 +07:00
|
|
|
|
2009-03-12 01:33:00 +07:00
|
|
|
/* set ring buffers to default size if not already done so */
|
|
|
|
int tracing_update_buffers(void);
|
|
|
|
|
2009-03-22 15:30:39 +07:00
|
|
|
struct ftrace_event_field {
|
|
|
|
struct list_head link;
|
2013-02-28 08:41:37 +07:00
|
|
|
const char *name;
|
|
|
|
const char *type;
|
2009-08-07 09:33:02 +07:00
|
|
|
int filter_type;
|
2009-03-22 15:30:39 +07:00
|
|
|
int offset;
|
|
|
|
int size;
|
2009-04-28 15:04:53 +07:00
|
|
|
int is_signed;
|
2009-03-22 15:30:39 +07:00
|
|
|
};
|
|
|
|
|
2009-04-28 15:04:47 +07:00
|
|
|
struct event_filter {
|
2011-01-28 10:42:43 +07:00
|
|
|
int n_preds; /* Number assigned */
|
|
|
|
int a_preds; /* allocated */
|
2011-01-28 10:49:48 +07:00
|
|
|
struct filter_pred *preds;
|
2011-01-28 10:54:33 +07:00
|
|
|
struct filter_pred *root;
|
tracing/filters: a better event parser
Replace the current event parser hack with a better one. Filters are
no longer specified predicate by predicate, but all at once and can
use parens and any of the following operators:
numeric fields:
==, !=, <, <=, >, >=
string fields:
==, !=
predicates can be combined with the logical operators:
&&, ||
examples:
"common_preempt_count > 4" > filter
"((sig >= 10 && sig < 15) || sig == 17) && comm != bash" > filter
If there was an error, the erroneous string along with an error
message can be seen by looking at the filter e.g.:
((sig >= 10 && sig < 15) || dsig == 17) && comm != bash
^
parse_error: Field not found
Currently the caret for an error always appears at the beginning of
the filter; a real position should be used, but the error message
should be useful even without it.
To clear a filter, '0' can be written to the filter file.
Filters can also be set or cleared for a complete subsystem by writing
the same filter as would be written to an individual event to the
filter file at the root of the subsytem. Note however, that if any
event in the subsystem lacks a field specified in the filter being
set, the set will fail and all filters in the subsytem are
automatically cleared. This change from the previous version was made
because using only the fields that happen to exist for a given event
would most likely result in a meaningless filter.
Because the logical operators are now implemented as predicates, the
maximum number of predicates in a filter was increased from 8 to 16.
[ Impact: add new, extended trace-filter implementation ]
Signed-off-by: Tom Zanussi <tzanussi@gmail.com>
Acked-by: Steven Rostedt <rostedt@goodmis.org>
Cc: fweisbec@gmail.com
Cc: Li Zefan <lizf@cn.fujitsu.com>
LKML-Reference: <1240905899.6416.121.camel@tropicana>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-04-28 15:04:59 +07:00
|
|
|
char *filter_string;
|
2009-04-28 15:04:47 +07:00
|
|
|
};
|
|
|
|
|
2009-03-22 15:31:17 +07:00
|
|
|
struct event_subsystem {
|
|
|
|
struct list_head list;
|
|
|
|
const char *name;
|
2009-07-20 09:20:53 +07:00
|
|
|
struct event_filter *filter;
|
2011-07-05 22:36:06 +07:00
|
|
|
int ref_count;
|
2009-03-22 15:31:17 +07:00
|
|
|
};
|
|
|
|
|
2015-05-14 01:59:40 +07:00
|
|
|
struct trace_subsystem_dir {
|
2012-05-04 10:09:03 +07:00
|
|
|
struct list_head list;
|
|
|
|
struct event_subsystem *subsystem;
|
|
|
|
struct trace_array *tr;
|
|
|
|
struct dentry *entry;
|
|
|
|
int ref_count;
|
|
|
|
int nr_events;
|
|
|
|
};
|
|
|
|
|
2016-04-27 21:13:46 +07:00
|
|
|
extern int call_filter_check_discard(struct trace_event_call *call, void *rec,
|
|
|
|
struct ring_buffer *buffer,
|
|
|
|
struct ring_buffer_event *event);
|
2016-04-28 23:04:13 +07:00
|
|
|
|
|
|
|
void trace_buffer_unlock_commit_regs(struct trace_array *tr,
|
|
|
|
struct ring_buffer *buffer,
|
|
|
|
struct ring_buffer_event *event,
|
|
|
|
unsigned long flags, int pc,
|
|
|
|
struct pt_regs *regs);
|
2016-04-30 04:44:01 +07:00
|
|
|
|
|
|
|
static inline void trace_buffer_unlock_commit(struct trace_array *tr,
|
|
|
|
struct ring_buffer *buffer,
|
|
|
|
struct ring_buffer_event *event,
|
|
|
|
unsigned long flags, int pc)
|
|
|
|
{
|
|
|
|
trace_buffer_unlock_commit_regs(tr, buffer, event, flags, pc, NULL);
|
|
|
|
}
|
|
|
|
|
2016-05-04 04:15:43 +07:00
|
|
|
DECLARE_PER_CPU(struct ring_buffer_event *, trace_buffered_event);
|
|
|
|
DECLARE_PER_CPU(int, trace_buffered_event_cnt);
|
|
|
|
void trace_buffered_event_disable(void);
|
|
|
|
void trace_buffered_event_enable(void);
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
__trace_event_discard_commit(struct ring_buffer *buffer,
|
|
|
|
struct ring_buffer_event *event)
|
|
|
|
{
|
|
|
|
if (this_cpu_read(trace_buffered_event) == event) {
|
|
|
|
/* Simply release the temp buffer */
|
|
|
|
this_cpu_dec(trace_buffered_event_cnt);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
ring_buffer_discard_commit(buffer, event);
|
|
|
|
}
|
|
|
|
|
2016-04-27 08:22:22 +07:00
|
|
|
/*
|
|
|
|
* Helper function for event_trigger_unlock_commit{_regs}().
|
|
|
|
* If there are event triggers attached to this event that requires
|
|
|
|
* filtering against its fields, then they wil be called as the
|
|
|
|
* entry already holds the field information of the current event.
|
|
|
|
*
|
|
|
|
* It also checks if the event should be discarded or not.
|
|
|
|
* It is to be discarded if the event is soft disabled and the
|
|
|
|
* event was only recorded to process triggers, or if the event
|
|
|
|
* filter is active and this event did not match the filters.
|
|
|
|
*
|
|
|
|
* Returns true if the event is discarded, false otherwise.
|
|
|
|
*/
|
|
|
|
static inline bool
|
|
|
|
__event_trigger_test_discard(struct trace_event_file *file,
|
|
|
|
struct ring_buffer *buffer,
|
|
|
|
struct ring_buffer_event *event,
|
|
|
|
void *entry,
|
|
|
|
enum event_trigger_type *tt)
|
|
|
|
{
|
|
|
|
unsigned long eflags = file->flags;
|
|
|
|
|
|
|
|
if (eflags & EVENT_FILE_FL_TRIGGER_COND)
|
|
|
|
*tt = event_triggers_call(file, entry);
|
|
|
|
|
2016-04-27 22:09:42 +07:00
|
|
|
if (test_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags) ||
|
|
|
|
(unlikely(file->flags & EVENT_FILE_FL_FILTERED) &&
|
|
|
|
!filter_match_preds(file->filter, entry))) {
|
2016-05-04 04:15:43 +07:00
|
|
|
__trace_event_discard_commit(buffer, event);
|
2016-04-27 22:09:42 +07:00
|
|
|
return true;
|
|
|
|
}
|
2016-04-27 08:22:22 +07:00
|
|
|
|
2016-04-27 22:09:42 +07:00
|
|
|
return false;
|
2016-04-27 08:22:22 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* event_trigger_unlock_commit - handle triggers and finish event commit
|
|
|
|
* @file: The file pointer assoctiated to the event
|
|
|
|
* @buffer: The ring buffer that the event is being written to
|
|
|
|
* @event: The event meta data in the ring buffer
|
|
|
|
* @entry: The event itself
|
|
|
|
* @irq_flags: The state of the interrupts at the start of the event
|
|
|
|
* @pc: The state of the preempt count at the start of the event.
|
|
|
|
*
|
|
|
|
* This is a helper function to handle triggers that require data
|
|
|
|
* from the event itself. It also tests the event against filters and
|
|
|
|
* if the event is soft disabled and should be discarded.
|
|
|
|
*/
|
|
|
|
static inline void
|
|
|
|
event_trigger_unlock_commit(struct trace_event_file *file,
|
|
|
|
struct ring_buffer *buffer,
|
|
|
|
struct ring_buffer_event *event,
|
|
|
|
void *entry, unsigned long irq_flags, int pc)
|
|
|
|
{
|
|
|
|
enum event_trigger_type tt = ETT_NONE;
|
|
|
|
|
|
|
|
if (!__event_trigger_test_discard(file, buffer, event, entry, &tt))
|
|
|
|
trace_buffer_unlock_commit(file->tr, buffer, event, irq_flags, pc);
|
|
|
|
|
|
|
|
if (tt)
|
|
|
|
event_triggers_post_call(file, tt, entry);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* event_trigger_unlock_commit_regs - handle triggers and finish event commit
|
|
|
|
* @file: The file pointer assoctiated to the event
|
|
|
|
* @buffer: The ring buffer that the event is being written to
|
|
|
|
* @event: The event meta data in the ring buffer
|
|
|
|
* @entry: The event itself
|
|
|
|
* @irq_flags: The state of the interrupts at the start of the event
|
|
|
|
* @pc: The state of the preempt count at the start of the event.
|
|
|
|
*
|
|
|
|
* This is a helper function to handle triggers that require data
|
|
|
|
* from the event itself. It also tests the event against filters and
|
|
|
|
* if the event is soft disabled and should be discarded.
|
|
|
|
*
|
|
|
|
* Same as event_trigger_unlock_commit() but calls
|
|
|
|
* trace_buffer_unlock_commit_regs() instead of trace_buffer_unlock_commit().
|
|
|
|
*/
|
|
|
|
static inline void
|
|
|
|
event_trigger_unlock_commit_regs(struct trace_event_file *file,
|
|
|
|
struct ring_buffer *buffer,
|
|
|
|
struct ring_buffer_event *event,
|
|
|
|
void *entry, unsigned long irq_flags, int pc,
|
|
|
|
struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
enum event_trigger_type tt = ETT_NONE;
|
|
|
|
|
|
|
|
if (!__event_trigger_test_discard(file, buffer, event, entry, &tt))
|
|
|
|
trace_buffer_unlock_commit_regs(file->tr, buffer, event,
|
|
|
|
irq_flags, pc, regs);
|
|
|
|
|
|
|
|
if (tt)
|
|
|
|
event_triggers_post_call(file, tt, entry);
|
|
|
|
}
|
|
|
|
|
2011-01-28 10:54:33 +07:00
|
|
|
#define FILTER_PRED_INVALID ((unsigned short)-1)
|
|
|
|
#define FILTER_PRED_IS_RIGHT (1 << 15)
|
2011-01-28 11:16:51 +07:00
|
|
|
#define FILTER_PRED_FOLD (1 << 15)
|
2011-01-28 10:54:33 +07:00
|
|
|
|
2011-01-28 11:21:34 +07:00
|
|
|
/*
|
|
|
|
* The max preds is the size of unsigned short with
|
|
|
|
* two flags at the MSBs. One bit is used for both the IS_RIGHT
|
|
|
|
* and FOLD flags. The other is reserved.
|
|
|
|
*
|
|
|
|
* 2^14 preds is way more than enough.
|
|
|
|
*/
|
|
|
|
#define MAX_FILTER_PRED 16384
|
2011-01-28 11:19:49 +07:00
|
|
|
|
2009-03-22 15:31:04 +07:00
|
|
|
struct filter_pred;
|
2009-09-25 02:10:44 +07:00
|
|
|
struct regex;
|
2009-03-22 15:31:04 +07:00
|
|
|
|
2011-01-28 10:37:09 +07:00
|
|
|
typedef int (*filter_pred_fn_t) (struct filter_pred *pred, void *event);
|
2009-03-22 15:31:04 +07:00
|
|
|
|
2009-09-25 02:10:44 +07:00
|
|
|
typedef int (*regex_match_func)(char *str, struct regex *r, int len);
|
|
|
|
|
2009-09-25 02:31:51 +07:00
|
|
|
enum regex_type {
|
2009-10-15 10:21:12 +07:00
|
|
|
MATCH_FULL = 0,
|
2009-09-25 02:31:51 +07:00
|
|
|
MATCH_FRONT_ONLY,
|
|
|
|
MATCH_MIDDLE_ONLY,
|
|
|
|
MATCH_END_ONLY,
|
2016-10-05 18:58:15 +07:00
|
|
|
MATCH_GLOB,
|
2009-09-25 02:31:51 +07:00
|
|
|
};
|
|
|
|
|
2009-09-25 02:10:44 +07:00
|
|
|
struct regex {
|
|
|
|
char pattern[MAX_FILTER_STR_VAL];
|
|
|
|
int len;
|
|
|
|
int field_len;
|
|
|
|
regex_match_func match;
|
|
|
|
};
|
|
|
|
|
2009-03-22 15:31:04 +07:00
|
|
|
struct filter_pred {
|
2009-09-25 02:10:44 +07:00
|
|
|
filter_pred_fn_t fn;
|
|
|
|
u64 val;
|
|
|
|
struct regex regex;
|
2011-08-11 21:25:47 +07:00
|
|
|
unsigned short *ops;
|
2011-08-11 21:25:54 +07:00
|
|
|
struct ftrace_event_field *field;
|
2009-09-25 02:10:44 +07:00
|
|
|
int offset;
|
|
|
|
int not;
|
|
|
|
int op;
|
2011-01-28 10:54:33 +07:00
|
|
|
unsigned short index;
|
|
|
|
unsigned short parent;
|
|
|
|
unsigned short left;
|
|
|
|
unsigned short right;
|
2009-03-22 15:31:04 +07:00
|
|
|
};
|
|
|
|
|
2015-12-11 01:50:43 +07:00
|
|
|
static inline bool is_string_field(struct ftrace_event_field *field)
|
|
|
|
{
|
|
|
|
return field->filter_type == FILTER_DYN_STRING ||
|
|
|
|
field->filter_type == FILTER_STATIC_STRING ||
|
2017-02-09 01:36:37 +07:00
|
|
|
field->filter_type == FILTER_PTR_STRING ||
|
|
|
|
field->filter_type == FILTER_COMM;
|
2015-12-11 01:50:43 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool is_function_field(struct ftrace_event_field *field)
|
|
|
|
{
|
|
|
|
return field->filter_type == FILTER_TRACE_FN;
|
|
|
|
}
|
|
|
|
|
2009-09-25 02:31:51 +07:00
|
|
|
extern enum regex_type
|
|
|
|
filter_parse_regex(char *buff, int len, char **search, int *not);
|
2015-05-05 21:09:53 +07:00
|
|
|
extern void print_event_filter(struct trace_event_file *file,
|
2009-03-24 14:14:31 +07:00
|
|
|
struct trace_seq *s);
|
2015-05-05 21:09:53 +07:00
|
|
|
extern int apply_event_filter(struct trace_event_file *file,
|
tracing/filters: a better event parser
Replace the current event parser hack with a better one. Filters are
no longer specified predicate by predicate, but all at once and can
use parens and any of the following operators:
numeric fields:
==, !=, <, <=, >, >=
string fields:
==, !=
predicates can be combined with the logical operators:
&&, ||
examples:
"common_preempt_count > 4" > filter
"((sig >= 10 && sig < 15) || sig == 17) && comm != bash" > filter
If there was an error, the erroneous string along with an error
message can be seen by looking at the filter e.g.:
((sig >= 10 && sig < 15) || dsig == 17) && comm != bash
^
parse_error: Field not found
Currently the caret for an error always appears at the beginning of
the filter; a real position should be used, but the error message
should be useful even without it.
To clear a filter, '0' can be written to the filter file.
Filters can also be set or cleared for a complete subsystem by writing
the same filter as would be written to an individual event to the
filter file at the root of the subsytem. Note however, that if any
event in the subsystem lacks a field specified in the filter being
set, the set will fail and all filters in the subsytem are
automatically cleared. This change from the previous version was made
because using only the fields that happen to exist for a given event
would most likely result in a meaningless filter.
Because the logical operators are now implemented as predicates, the
maximum number of predicates in a filter was increased from 8 to 16.
[ Impact: add new, extended trace-filter implementation ]
Signed-off-by: Tom Zanussi <tzanussi@gmail.com>
Acked-by: Steven Rostedt <rostedt@goodmis.org>
Cc: fweisbec@gmail.com
Cc: Li Zefan <lizf@cn.fujitsu.com>
LKML-Reference: <1240905899.6416.121.camel@tropicana>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-04-28 15:04:59 +07:00
|
|
|
char *filter_string);
|
2015-05-14 01:59:40 +07:00
|
|
|
extern int apply_subsystem_event_filter(struct trace_subsystem_dir *dir,
|
tracing/filters: a better event parser
Replace the current event parser hack with a better one. Filters are
no longer specified predicate by predicate, but all at once and can
use parens and any of the following operators:
numeric fields:
==, !=, <, <=, >, >=
string fields:
==, !=
predicates can be combined with the logical operators:
&&, ||
examples:
"common_preempt_count > 4" > filter
"((sig >= 10 && sig < 15) || sig == 17) && comm != bash" > filter
If there was an error, the erroneous string along with an error
message can be seen by looking at the filter e.g.:
((sig >= 10 && sig < 15) || dsig == 17) && comm != bash
^
parse_error: Field not found
Currently the caret for an error always appears at the beginning of
the filter; a real position should be used, but the error message
should be useful even without it.
To clear a filter, '0' can be written to the filter file.
Filters can also be set or cleared for a complete subsystem by writing
the same filter as would be written to an individual event to the
filter file at the root of the subsytem. Note however, that if any
event in the subsystem lacks a field specified in the filter being
set, the set will fail and all filters in the subsytem are
automatically cleared. This change from the previous version was made
because using only the fields that happen to exist for a given event
would most likely result in a meaningless filter.
Because the logical operators are now implemented as predicates, the
maximum number of predicates in a filter was increased from 8 to 16.
[ Impact: add new, extended trace-filter implementation ]
Signed-off-by: Tom Zanussi <tzanussi@gmail.com>
Acked-by: Steven Rostedt <rostedt@goodmis.org>
Cc: fweisbec@gmail.com
Cc: Li Zefan <lizf@cn.fujitsu.com>
LKML-Reference: <1240905899.6416.121.camel@tropicana>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-04-28 15:04:59 +07:00
|
|
|
char *filter_string);
|
|
|
|
extern void print_subsystem_event_filter(struct event_subsystem *system,
|
2009-04-17 12:27:08 +07:00
|
|
|
struct trace_seq *s);
|
2009-08-07 09:33:02 +07:00
|
|
|
extern int filter_assign_type(const char *type);
|
2015-05-05 22:45:27 +07:00
|
|
|
extern int create_event_filter(struct trace_event_call *call,
|
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>
2013-10-24 20:59:29 +07:00
|
|
|
char *filter_str, bool set_str,
|
|
|
|
struct event_filter **filterp);
|
|
|
|
extern void free_event_filter(struct event_filter *filter);
|
2009-03-22 15:31:04 +07:00
|
|
|
|
2013-03-11 14:13:42 +07:00
|
|
|
struct ftrace_event_field *
|
2015-05-05 22:45:27 +07:00
|
|
|
trace_find_event_field(struct trace_event_call *call, char *name);
|
2010-04-22 21:35:55 +07:00
|
|
|
|
2010-07-02 10:07:32 +07:00
|
|
|
extern void trace_event_enable_cmd_record(bool enable);
|
2012-08-04 03:10:49 +07:00
|
|
|
extern int event_trace_add_tracer(struct dentry *parent, struct trace_array *tr);
|
2012-08-08 03:14:16 +07:00
|
|
|
extern int event_trace_del_tracer(struct trace_array *tr);
|
2010-07-02 10:07:32 +07:00
|
|
|
|
2015-05-05 21:09:53 +07:00
|
|
|
extern struct trace_event_file *find_event_file(struct trace_array *tr,
|
|
|
|
const char *system,
|
|
|
|
const char *event);
|
2013-10-24 20:59:28 +07:00
|
|
|
|
tracing: Add basic event trigger framework
Add a 'trigger' file for each trace event, enabling 'trace event
triggers' to be set for trace events.
'trace event triggers' are patterned after the existing 'ftrace
function triggers' implementation except that triggers are written to
per-event 'trigger' files instead of to a single file such as the
'set_ftrace_filter' used for ftrace function triggers.
The implementation is meant to be entirely separate from ftrace
function triggers, in order to keep the respective implementations
relatively simple and to allow them to diverge.
The event trigger functionality is built on top of SOFT_DISABLE
functionality. It adds a TRIGGER_MODE bit to the ftrace_event_file
flags which is checked when any trace event fires. Triggers set for a
particular event need to be checked regardless of whether that event
is actually enabled or not - getting an event to fire even if it's not
enabled is what's already implemented by SOFT_DISABLE mode, so trigger
mode directly reuses that. Event trigger essentially inherit the soft
disable logic in __ftrace_event_enable_disable() while adding a bit of
logic and trigger reference counting via tm_ref on top of that in a
new trace_event_trigger_enable_disable() function. Because the base
__ftrace_event_enable_disable() code now needs to be invoked from
outside trace_events.c, a wrapper is also added for those usages.
The triggers for an event are actually invoked via a new function,
event_triggers_call(), and code is also added to invoke them for
ftrace_raw_event calls as well as syscall events.
The main part of the patch creates a new trace_events_trigger.c file
to contain the trace event triggers implementation.
The standard open, read, and release file operations are implemented
here.
The open() implementation sets up for the various open modes of the
'trigger' file. It creates and attaches the trigger iterator and sets
up the command parser. If opened for reading set up the trigger
seq_ops.
The read() implementation parses the event trigger written to the
'trigger' file, looks up the trigger command, and passes it along to
that event_command's func() implementation for command-specific
processing.
The release() implementation does whatever cleanup is needed to
release the 'trigger' file, like releasing the parser and trigger
iterator, etc.
A couple of functions for event command registration and
unregistration are added, along with a list to add them to and a mutex
to protect them, as well as an (initially empty) registration function
to add the set of commands that will be added by future commits, and
call to it from the trace event initialization code.
also added are a couple trigger-specific data structures needed for
these implementations such as a trigger iterator and a struct for
trigger-specific data.
A couple structs consisting mostly of function meant to be implemented
in command-specific ways, event_command and event_trigger_ops, are
used by the generic event trigger command implementations. They're
being put into trace.h alongside the other trace_event data structures
and functions, in the expectation that they'll be needed in several
trace_event-related files such as trace_events_trigger.c and
trace_events.c.
The event_command.func() function is meant to be called by the trigger
parsing code in order to add a trigger instance to the corresponding
event. It essentially coordinates adding a live trigger instance to
the event, and arming the triggering the event.
Every event_command func() implementation essentially does the
same thing for any command:
- choose ops - use the value of param to choose either a number or
count version of event_trigger_ops specific to the command
- do the register or unregister of those ops
- associate a filter, if specified, with the triggering event
The reg() and unreg() ops allow command-specific implementations for
event_trigger_op registration and unregistration, and the
get_trigger_ops() op allows command-specific event_trigger_ops
selection to be parameterized. When a trigger instance is added, the
reg() op essentially adds that trigger to the triggering event and
arms it, while unreg() does the opposite. The set_filter() function
is used to associate a filter with the trigger - if the command
doesn't specify a set_filter() implementation, the command will ignore
filters.
Each command has an associated trigger_type, which serves double duty,
both as a unique identifier for the command as well as a value that
can be used for setting a trigger mode bit during trigger invocation.
The signature of func() adds a pointer to the event_command struct,
used to invoke those functions, along with a command_data param that
can be passed to the reg/unreg functions. This allows func()
implementations to use command-specific blobs and supports code
re-use.
The event_trigger_ops.func() command corrsponds to the trigger 'probe'
function that gets called when the triggering event is actually
invoked. The other functions are used to list the trigger when
needed, along with a couple mundane book-keeping functions.
This also moves event_file_data() into trace.h so it can be used
outside of trace_events.c.
Link: http://lkml.kernel.org/r/316d95061accdee070aac8e5750afba0192fa5b9.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Idea-by: Steve Rostedt <rostedt@goodmis.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 20:59:24 +07:00
|
|
|
static inline void *event_file_data(struct file *filp)
|
|
|
|
{
|
|
|
|
return ACCESS_ONCE(file_inode(filp)->i_private);
|
|
|
|
}
|
|
|
|
|
2009-05-06 09:33:45 +07:00
|
|
|
extern struct mutex event_mutex;
|
2009-04-11 00:52:20 +07:00
|
|
|
extern struct list_head ftrace_events;
|
2009-03-20 02:26:15 +07:00
|
|
|
|
tracing: Add basic event trigger framework
Add a 'trigger' file for each trace event, enabling 'trace event
triggers' to be set for trace events.
'trace event triggers' are patterned after the existing 'ftrace
function triggers' implementation except that triggers are written to
per-event 'trigger' files instead of to a single file such as the
'set_ftrace_filter' used for ftrace function triggers.
The implementation is meant to be entirely separate from ftrace
function triggers, in order to keep the respective implementations
relatively simple and to allow them to diverge.
The event trigger functionality is built on top of SOFT_DISABLE
functionality. It adds a TRIGGER_MODE bit to the ftrace_event_file
flags which is checked when any trace event fires. Triggers set for a
particular event need to be checked regardless of whether that event
is actually enabled or not - getting an event to fire even if it's not
enabled is what's already implemented by SOFT_DISABLE mode, so trigger
mode directly reuses that. Event trigger essentially inherit the soft
disable logic in __ftrace_event_enable_disable() while adding a bit of
logic and trigger reference counting via tm_ref on top of that in a
new trace_event_trigger_enable_disable() function. Because the base
__ftrace_event_enable_disable() code now needs to be invoked from
outside trace_events.c, a wrapper is also added for those usages.
The triggers for an event are actually invoked via a new function,
event_triggers_call(), and code is also added to invoke them for
ftrace_raw_event calls as well as syscall events.
The main part of the patch creates a new trace_events_trigger.c file
to contain the trace event triggers implementation.
The standard open, read, and release file operations are implemented
here.
The open() implementation sets up for the various open modes of the
'trigger' file. It creates and attaches the trigger iterator and sets
up the command parser. If opened for reading set up the trigger
seq_ops.
The read() implementation parses the event trigger written to the
'trigger' file, looks up the trigger command, and passes it along to
that event_command's func() implementation for command-specific
processing.
The release() implementation does whatever cleanup is needed to
release the 'trigger' file, like releasing the parser and trigger
iterator, etc.
A couple of functions for event command registration and
unregistration are added, along with a list to add them to and a mutex
to protect them, as well as an (initially empty) registration function
to add the set of commands that will be added by future commits, and
call to it from the trace event initialization code.
also added are a couple trigger-specific data structures needed for
these implementations such as a trigger iterator and a struct for
trigger-specific data.
A couple structs consisting mostly of function meant to be implemented
in command-specific ways, event_command and event_trigger_ops, are
used by the generic event trigger command implementations. They're
being put into trace.h alongside the other trace_event data structures
and functions, in the expectation that they'll be needed in several
trace_event-related files such as trace_events_trigger.c and
trace_events.c.
The event_command.func() function is meant to be called by the trigger
parsing code in order to add a trigger instance to the corresponding
event. It essentially coordinates adding a live trigger instance to
the event, and arming the triggering the event.
Every event_command func() implementation essentially does the
same thing for any command:
- choose ops - use the value of param to choose either a number or
count version of event_trigger_ops specific to the command
- do the register or unregister of those ops
- associate a filter, if specified, with the triggering event
The reg() and unreg() ops allow command-specific implementations for
event_trigger_op registration and unregistration, and the
get_trigger_ops() op allows command-specific event_trigger_ops
selection to be parameterized. When a trigger instance is added, the
reg() op essentially adds that trigger to the triggering event and
arms it, while unreg() does the opposite. The set_filter() function
is used to associate a filter with the trigger - if the command
doesn't specify a set_filter() implementation, the command will ignore
filters.
Each command has an associated trigger_type, which serves double duty,
both as a unique identifier for the command as well as a value that
can be used for setting a trigger mode bit during trigger invocation.
The signature of func() adds a pointer to the event_command struct,
used to invoke those functions, along with a command_data param that
can be passed to the reg/unreg functions. This allows func()
implementations to use command-specific blobs and supports code
re-use.
The event_trigger_ops.func() command corrsponds to the trigger 'probe'
function that gets called when the triggering event is actually
invoked. The other functions are used to list the trigger when
needed, along with a couple mundane book-keeping functions.
This also moves event_file_data() into trace.h so it can be used
outside of trace_events.c.
Link: http://lkml.kernel.org/r/316d95061accdee070aac8e5750afba0192fa5b9.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Idea-by: Steve Rostedt <rostedt@goodmis.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 20:59:24 +07:00
|
|
|
extern const struct file_operations event_trigger_fops;
|
tracing: Add 'hist' event trigger command
'hist' triggers allow users to continually aggregate trace events,
which can then be viewed afterwards by simply reading a 'hist' file
containing the aggregation in a human-readable format.
The basic idea is very simple and boils down to a mechanism whereby
trace events, rather than being exhaustively dumped in raw form and
viewed directly, are automatically 'compressed' into meaningful tables
completely defined by the user.
This is done strictly via single-line command-line commands and
without the aid of any kind of programming language or interpreter.
A surprising number of typical use cases can be accomplished by users
via this simple mechanism. In fact, a large number of the tasks that
users typically do using the more complicated script-based tracing
tools, at least during the initial stages of an investigation, can be
accomplished by simply specifying a set of keys and values to be used
in the creation of a hash table.
The Linux kernel trace event subsystem happens to provide an extensive
list of keys and values ready-made for such a purpose in the form of
the event format files associated with each trace event. By simply
consulting the format file for field names of interest and by plugging
them into the hist trigger command, users can create an endless number
of useful aggregations to help with investigating various properties
of the system. See Documentation/trace/events.txt for examples.
hist triggers are implemented on top of the existing event trigger
infrastructure, and as such are consistent with the existing triggers
from a user's perspective as well.
The basic syntax follows the existing trigger syntax. Users start an
aggregation by writing a 'hist' trigger to the event of interest's
trigger file:
# echo hist:keys=xxx [ if filter] > event/trigger
Once a hist trigger has been set up, by default it continually
aggregates every matching event into a hash table using the event key
and a value field named 'hitcount'.
To view the aggregation at any point in time, simply read the 'hist'
file in the same directory as the 'trigger' file:
# cat event/hist
The detailed syntax provides additional options for user control, and
is described exhaustively in Documentation/trace/events.txt and in the
virtual tracing/README file in the tracing subsystem.
Link: http://lkml.kernel.org/r/72d263b5e1853fe9c314953b65833c3aa75479f2.1457029949.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Tested-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Reviewed-by: Namhyung Kim <namhyung@kernel.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2016-03-04 01:54:42 +07:00
|
|
|
extern const struct file_operations event_hist_fops;
|
|
|
|
|
|
|
|
#ifdef CONFIG_HIST_TRIGGERS
|
|
|
|
extern int register_trigger_hist_cmd(void);
|
2016-03-04 01:54:55 +07:00
|
|
|
extern int register_trigger_hist_enable_disable_cmds(void);
|
tracing: Add 'hist' event trigger command
'hist' triggers allow users to continually aggregate trace events,
which can then be viewed afterwards by simply reading a 'hist' file
containing the aggregation in a human-readable format.
The basic idea is very simple and boils down to a mechanism whereby
trace events, rather than being exhaustively dumped in raw form and
viewed directly, are automatically 'compressed' into meaningful tables
completely defined by the user.
This is done strictly via single-line command-line commands and
without the aid of any kind of programming language or interpreter.
A surprising number of typical use cases can be accomplished by users
via this simple mechanism. In fact, a large number of the tasks that
users typically do using the more complicated script-based tracing
tools, at least during the initial stages of an investigation, can be
accomplished by simply specifying a set of keys and values to be used
in the creation of a hash table.
The Linux kernel trace event subsystem happens to provide an extensive
list of keys and values ready-made for such a purpose in the form of
the event format files associated with each trace event. By simply
consulting the format file for field names of interest and by plugging
them into the hist trigger command, users can create an endless number
of useful aggregations to help with investigating various properties
of the system. See Documentation/trace/events.txt for examples.
hist triggers are implemented on top of the existing event trigger
infrastructure, and as such are consistent with the existing triggers
from a user's perspective as well.
The basic syntax follows the existing trigger syntax. Users start an
aggregation by writing a 'hist' trigger to the event of interest's
trigger file:
# echo hist:keys=xxx [ if filter] > event/trigger
Once a hist trigger has been set up, by default it continually
aggregates every matching event into a hash table using the event key
and a value field named 'hitcount'.
To view the aggregation at any point in time, simply read the 'hist'
file in the same directory as the 'trigger' file:
# cat event/hist
The detailed syntax provides additional options for user control, and
is described exhaustively in Documentation/trace/events.txt and in the
virtual tracing/README file in the tracing subsystem.
Link: http://lkml.kernel.org/r/72d263b5e1853fe9c314953b65833c3aa75479f2.1457029949.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Tested-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Reviewed-by: Namhyung Kim <namhyung@kernel.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2016-03-04 01:54:42 +07:00
|
|
|
#else
|
|
|
|
static inline int register_trigger_hist_cmd(void) { return 0; }
|
2016-03-04 01:54:55 +07:00
|
|
|
static inline int register_trigger_hist_enable_disable_cmds(void) { return 0; }
|
tracing: Add 'hist' event trigger command
'hist' triggers allow users to continually aggregate trace events,
which can then be viewed afterwards by simply reading a 'hist' file
containing the aggregation in a human-readable format.
The basic idea is very simple and boils down to a mechanism whereby
trace events, rather than being exhaustively dumped in raw form and
viewed directly, are automatically 'compressed' into meaningful tables
completely defined by the user.
This is done strictly via single-line command-line commands and
without the aid of any kind of programming language or interpreter.
A surprising number of typical use cases can be accomplished by users
via this simple mechanism. In fact, a large number of the tasks that
users typically do using the more complicated script-based tracing
tools, at least during the initial stages of an investigation, can be
accomplished by simply specifying a set of keys and values to be used
in the creation of a hash table.
The Linux kernel trace event subsystem happens to provide an extensive
list of keys and values ready-made for such a purpose in the form of
the event format files associated with each trace event. By simply
consulting the format file for field names of interest and by plugging
them into the hist trigger command, users can create an endless number
of useful aggregations to help with investigating various properties
of the system. See Documentation/trace/events.txt for examples.
hist triggers are implemented on top of the existing event trigger
infrastructure, and as such are consistent with the existing triggers
from a user's perspective as well.
The basic syntax follows the existing trigger syntax. Users start an
aggregation by writing a 'hist' trigger to the event of interest's
trigger file:
# echo hist:keys=xxx [ if filter] > event/trigger
Once a hist trigger has been set up, by default it continually
aggregates every matching event into a hash table using the event key
and a value field named 'hitcount'.
To view the aggregation at any point in time, simply read the 'hist'
file in the same directory as the 'trigger' file:
# cat event/hist
The detailed syntax provides additional options for user control, and
is described exhaustively in Documentation/trace/events.txt and in the
virtual tracing/README file in the tracing subsystem.
Link: http://lkml.kernel.org/r/72d263b5e1853fe9c314953b65833c3aa75479f2.1457029949.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Tested-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Reviewed-by: Namhyung Kim <namhyung@kernel.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2016-03-04 01:54:42 +07:00
|
|
|
#endif
|
tracing: Add basic event trigger framework
Add a 'trigger' file for each trace event, enabling 'trace event
triggers' to be set for trace events.
'trace event triggers' are patterned after the existing 'ftrace
function triggers' implementation except that triggers are written to
per-event 'trigger' files instead of to a single file such as the
'set_ftrace_filter' used for ftrace function triggers.
The implementation is meant to be entirely separate from ftrace
function triggers, in order to keep the respective implementations
relatively simple and to allow them to diverge.
The event trigger functionality is built on top of SOFT_DISABLE
functionality. It adds a TRIGGER_MODE bit to the ftrace_event_file
flags which is checked when any trace event fires. Triggers set for a
particular event need to be checked regardless of whether that event
is actually enabled or not - getting an event to fire even if it's not
enabled is what's already implemented by SOFT_DISABLE mode, so trigger
mode directly reuses that. Event trigger essentially inherit the soft
disable logic in __ftrace_event_enable_disable() while adding a bit of
logic and trigger reference counting via tm_ref on top of that in a
new trace_event_trigger_enable_disable() function. Because the base
__ftrace_event_enable_disable() code now needs to be invoked from
outside trace_events.c, a wrapper is also added for those usages.
The triggers for an event are actually invoked via a new function,
event_triggers_call(), and code is also added to invoke them for
ftrace_raw_event calls as well as syscall events.
The main part of the patch creates a new trace_events_trigger.c file
to contain the trace event triggers implementation.
The standard open, read, and release file operations are implemented
here.
The open() implementation sets up for the various open modes of the
'trigger' file. It creates and attaches the trigger iterator and sets
up the command parser. If opened for reading set up the trigger
seq_ops.
The read() implementation parses the event trigger written to the
'trigger' file, looks up the trigger command, and passes it along to
that event_command's func() implementation for command-specific
processing.
The release() implementation does whatever cleanup is needed to
release the 'trigger' file, like releasing the parser and trigger
iterator, etc.
A couple of functions for event command registration and
unregistration are added, along with a list to add them to and a mutex
to protect them, as well as an (initially empty) registration function
to add the set of commands that will be added by future commits, and
call to it from the trace event initialization code.
also added are a couple trigger-specific data structures needed for
these implementations such as a trigger iterator and a struct for
trigger-specific data.
A couple structs consisting mostly of function meant to be implemented
in command-specific ways, event_command and event_trigger_ops, are
used by the generic event trigger command implementations. They're
being put into trace.h alongside the other trace_event data structures
and functions, in the expectation that they'll be needed in several
trace_event-related files such as trace_events_trigger.c and
trace_events.c.
The event_command.func() function is meant to be called by the trigger
parsing code in order to add a trigger instance to the corresponding
event. It essentially coordinates adding a live trigger instance to
the event, and arming the triggering the event.
Every event_command func() implementation essentially does the
same thing for any command:
- choose ops - use the value of param to choose either a number or
count version of event_trigger_ops specific to the command
- do the register or unregister of those ops
- associate a filter, if specified, with the triggering event
The reg() and unreg() ops allow command-specific implementations for
event_trigger_op registration and unregistration, and the
get_trigger_ops() op allows command-specific event_trigger_ops
selection to be parameterized. When a trigger instance is added, the
reg() op essentially adds that trigger to the triggering event and
arms it, while unreg() does the opposite. The set_filter() function
is used to associate a filter with the trigger - if the command
doesn't specify a set_filter() implementation, the command will ignore
filters.
Each command has an associated trigger_type, which serves double duty,
both as a unique identifier for the command as well as a value that
can be used for setting a trigger mode bit during trigger invocation.
The signature of func() adds a pointer to the event_command struct,
used to invoke those functions, along with a command_data param that
can be passed to the reg/unreg functions. This allows func()
implementations to use command-specific blobs and supports code
re-use.
The event_trigger_ops.func() command corrsponds to the trigger 'probe'
function that gets called when the triggering event is actually
invoked. The other functions are used to list the trigger when
needed, along with a couple mundane book-keeping functions.
This also moves event_file_data() into trace.h so it can be used
outside of trace_events.c.
Link: http://lkml.kernel.org/r/316d95061accdee070aac8e5750afba0192fa5b9.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Idea-by: Steve Rostedt <rostedt@goodmis.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 20:59:24 +07:00
|
|
|
|
|
|
|
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;
|
2013-12-22 09:55:17 +07:00
|
|
|
struct event_filter __rcu *filter;
|
tracing: Add basic event trigger framework
Add a 'trigger' file for each trace event, enabling 'trace event
triggers' to be set for trace events.
'trace event triggers' are patterned after the existing 'ftrace
function triggers' implementation except that triggers are written to
per-event 'trigger' files instead of to a single file such as the
'set_ftrace_filter' used for ftrace function triggers.
The implementation is meant to be entirely separate from ftrace
function triggers, in order to keep the respective implementations
relatively simple and to allow them to diverge.
The event trigger functionality is built on top of SOFT_DISABLE
functionality. It adds a TRIGGER_MODE bit to the ftrace_event_file
flags which is checked when any trace event fires. Triggers set for a
particular event need to be checked regardless of whether that event
is actually enabled or not - getting an event to fire even if it's not
enabled is what's already implemented by SOFT_DISABLE mode, so trigger
mode directly reuses that. Event trigger essentially inherit the soft
disable logic in __ftrace_event_enable_disable() while adding a bit of
logic and trigger reference counting via tm_ref on top of that in a
new trace_event_trigger_enable_disable() function. Because the base
__ftrace_event_enable_disable() code now needs to be invoked from
outside trace_events.c, a wrapper is also added for those usages.
The triggers for an event are actually invoked via a new function,
event_triggers_call(), and code is also added to invoke them for
ftrace_raw_event calls as well as syscall events.
The main part of the patch creates a new trace_events_trigger.c file
to contain the trace event triggers implementation.
The standard open, read, and release file operations are implemented
here.
The open() implementation sets up for the various open modes of the
'trigger' file. It creates and attaches the trigger iterator and sets
up the command parser. If opened for reading set up the trigger
seq_ops.
The read() implementation parses the event trigger written to the
'trigger' file, looks up the trigger command, and passes it along to
that event_command's func() implementation for command-specific
processing.
The release() implementation does whatever cleanup is needed to
release the 'trigger' file, like releasing the parser and trigger
iterator, etc.
A couple of functions for event command registration and
unregistration are added, along with a list to add them to and a mutex
to protect them, as well as an (initially empty) registration function
to add the set of commands that will be added by future commits, and
call to it from the trace event initialization code.
also added are a couple trigger-specific data structures needed for
these implementations such as a trigger iterator and a struct for
trigger-specific data.
A couple structs consisting mostly of function meant to be implemented
in command-specific ways, event_command and event_trigger_ops, are
used by the generic event trigger command implementations. They're
being put into trace.h alongside the other trace_event data structures
and functions, in the expectation that they'll be needed in several
trace_event-related files such as trace_events_trigger.c and
trace_events.c.
The event_command.func() function is meant to be called by the trigger
parsing code in order to add a trigger instance to the corresponding
event. It essentially coordinates adding a live trigger instance to
the event, and arming the triggering the event.
Every event_command func() implementation essentially does the
same thing for any command:
- choose ops - use the value of param to choose either a number or
count version of event_trigger_ops specific to the command
- do the register or unregister of those ops
- associate a filter, if specified, with the triggering event
The reg() and unreg() ops allow command-specific implementations for
event_trigger_op registration and unregistration, and the
get_trigger_ops() op allows command-specific event_trigger_ops
selection to be parameterized. When a trigger instance is added, the
reg() op essentially adds that trigger to the triggering event and
arms it, while unreg() does the opposite. The set_filter() function
is used to associate a filter with the trigger - if the command
doesn't specify a set_filter() implementation, the command will ignore
filters.
Each command has an associated trigger_type, which serves double duty,
both as a unique identifier for the command as well as a value that
can be used for setting a trigger mode bit during trigger invocation.
The signature of func() adds a pointer to the event_command struct,
used to invoke those functions, along with a command_data param that
can be passed to the reg/unreg functions. This allows func()
implementations to use command-specific blobs and supports code
re-use.
The event_trigger_ops.func() command corrsponds to the trigger 'probe'
function that gets called when the triggering event is actually
invoked. The other functions are used to list the trigger when
needed, along with a couple mundane book-keeping functions.
This also moves event_file_data() into trace.h so it can be used
outside of trace_events.c.
Link: http://lkml.kernel.org/r/316d95061accdee070aac8e5750afba0192fa5b9.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Idea-by: Steve Rostedt <rostedt@goodmis.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 20:59:24 +07:00
|
|
|
char *filter_str;
|
|
|
|
void *private_data;
|
2015-12-11 01:50:47 +07:00
|
|
|
bool paused;
|
2016-03-04 01:54:58 +07:00
|
|
|
bool paused_tmp;
|
tracing: Add basic event trigger framework
Add a 'trigger' file for each trace event, enabling 'trace event
triggers' to be set for trace events.
'trace event triggers' are patterned after the existing 'ftrace
function triggers' implementation except that triggers are written to
per-event 'trigger' files instead of to a single file such as the
'set_ftrace_filter' used for ftrace function triggers.
The implementation is meant to be entirely separate from ftrace
function triggers, in order to keep the respective implementations
relatively simple and to allow them to diverge.
The event trigger functionality is built on top of SOFT_DISABLE
functionality. It adds a TRIGGER_MODE bit to the ftrace_event_file
flags which is checked when any trace event fires. Triggers set for a
particular event need to be checked regardless of whether that event
is actually enabled or not - getting an event to fire even if it's not
enabled is what's already implemented by SOFT_DISABLE mode, so trigger
mode directly reuses that. Event trigger essentially inherit the soft
disable logic in __ftrace_event_enable_disable() while adding a bit of
logic and trigger reference counting via tm_ref on top of that in a
new trace_event_trigger_enable_disable() function. Because the base
__ftrace_event_enable_disable() code now needs to be invoked from
outside trace_events.c, a wrapper is also added for those usages.
The triggers for an event are actually invoked via a new function,
event_triggers_call(), and code is also added to invoke them for
ftrace_raw_event calls as well as syscall events.
The main part of the patch creates a new trace_events_trigger.c file
to contain the trace event triggers implementation.
The standard open, read, and release file operations are implemented
here.
The open() implementation sets up for the various open modes of the
'trigger' file. It creates and attaches the trigger iterator and sets
up the command parser. If opened for reading set up the trigger
seq_ops.
The read() implementation parses the event trigger written to the
'trigger' file, looks up the trigger command, and passes it along to
that event_command's func() implementation for command-specific
processing.
The release() implementation does whatever cleanup is needed to
release the 'trigger' file, like releasing the parser and trigger
iterator, etc.
A couple of functions for event command registration and
unregistration are added, along with a list to add them to and a mutex
to protect them, as well as an (initially empty) registration function
to add the set of commands that will be added by future commits, and
call to it from the trace event initialization code.
also added are a couple trigger-specific data structures needed for
these implementations such as a trigger iterator and a struct for
trigger-specific data.
A couple structs consisting mostly of function meant to be implemented
in command-specific ways, event_command and event_trigger_ops, are
used by the generic event trigger command implementations. They're
being put into trace.h alongside the other trace_event data structures
and functions, in the expectation that they'll be needed in several
trace_event-related files such as trace_events_trigger.c and
trace_events.c.
The event_command.func() function is meant to be called by the trigger
parsing code in order to add a trigger instance to the corresponding
event. It essentially coordinates adding a live trigger instance to
the event, and arming the triggering the event.
Every event_command func() implementation essentially does the
same thing for any command:
- choose ops - use the value of param to choose either a number or
count version of event_trigger_ops specific to the command
- do the register or unregister of those ops
- associate a filter, if specified, with the triggering event
The reg() and unreg() ops allow command-specific implementations for
event_trigger_op registration and unregistration, and the
get_trigger_ops() op allows command-specific event_trigger_ops
selection to be parameterized. When a trigger instance is added, the
reg() op essentially adds that trigger to the triggering event and
arms it, while unreg() does the opposite. The set_filter() function
is used to associate a filter with the trigger - if the command
doesn't specify a set_filter() implementation, the command will ignore
filters.
Each command has an associated trigger_type, which serves double duty,
both as a unique identifier for the command as well as a value that
can be used for setting a trigger mode bit during trigger invocation.
The signature of func() adds a pointer to the event_command struct,
used to invoke those functions, along with a command_data param that
can be passed to the reg/unreg functions. This allows func()
implementations to use command-specific blobs and supports code
re-use.
The event_trigger_ops.func() command corrsponds to the trigger 'probe'
function that gets called when the triggering event is actually
invoked. The other functions are used to list the trigger when
needed, along with a couple mundane book-keeping functions.
This also moves event_file_data() into trace.h so it can be used
outside of trace_events.c.
Link: http://lkml.kernel.org/r/316d95061accdee070aac8e5750afba0192fa5b9.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Idea-by: Steve Rostedt <rostedt@goodmis.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 20:59:24 +07:00
|
|
|
struct list_head list;
|
2016-03-04 01:54:58 +07:00
|
|
|
char *name;
|
|
|
|
struct list_head named_list;
|
|
|
|
struct event_trigger_data *named_data;
|
tracing: Add basic event trigger framework
Add a 'trigger' file for each trace event, enabling 'trace event
triggers' to be set for trace events.
'trace event triggers' are patterned after the existing 'ftrace
function triggers' implementation except that triggers are written to
per-event 'trigger' files instead of to a single file such as the
'set_ftrace_filter' used for ftrace function triggers.
The implementation is meant to be entirely separate from ftrace
function triggers, in order to keep the respective implementations
relatively simple and to allow them to diverge.
The event trigger functionality is built on top of SOFT_DISABLE
functionality. It adds a TRIGGER_MODE bit to the ftrace_event_file
flags which is checked when any trace event fires. Triggers set for a
particular event need to be checked regardless of whether that event
is actually enabled or not - getting an event to fire even if it's not
enabled is what's already implemented by SOFT_DISABLE mode, so trigger
mode directly reuses that. Event trigger essentially inherit the soft
disable logic in __ftrace_event_enable_disable() while adding a bit of
logic and trigger reference counting via tm_ref on top of that in a
new trace_event_trigger_enable_disable() function. Because the base
__ftrace_event_enable_disable() code now needs to be invoked from
outside trace_events.c, a wrapper is also added for those usages.
The triggers for an event are actually invoked via a new function,
event_triggers_call(), and code is also added to invoke them for
ftrace_raw_event calls as well as syscall events.
The main part of the patch creates a new trace_events_trigger.c file
to contain the trace event triggers implementation.
The standard open, read, and release file operations are implemented
here.
The open() implementation sets up for the various open modes of the
'trigger' file. It creates and attaches the trigger iterator and sets
up the command parser. If opened for reading set up the trigger
seq_ops.
The read() implementation parses the event trigger written to the
'trigger' file, looks up the trigger command, and passes it along to
that event_command's func() implementation for command-specific
processing.
The release() implementation does whatever cleanup is needed to
release the 'trigger' file, like releasing the parser and trigger
iterator, etc.
A couple of functions for event command registration and
unregistration are added, along with a list to add them to and a mutex
to protect them, as well as an (initially empty) registration function
to add the set of commands that will be added by future commits, and
call to it from the trace event initialization code.
also added are a couple trigger-specific data structures needed for
these implementations such as a trigger iterator and a struct for
trigger-specific data.
A couple structs consisting mostly of function meant to be implemented
in command-specific ways, event_command and event_trigger_ops, are
used by the generic event trigger command implementations. They're
being put into trace.h alongside the other trace_event data structures
and functions, in the expectation that they'll be needed in several
trace_event-related files such as trace_events_trigger.c and
trace_events.c.
The event_command.func() function is meant to be called by the trigger
parsing code in order to add a trigger instance to the corresponding
event. It essentially coordinates adding a live trigger instance to
the event, and arming the triggering the event.
Every event_command func() implementation essentially does the
same thing for any command:
- choose ops - use the value of param to choose either a number or
count version of event_trigger_ops specific to the command
- do the register or unregister of those ops
- associate a filter, if specified, with the triggering event
The reg() and unreg() ops allow command-specific implementations for
event_trigger_op registration and unregistration, and the
get_trigger_ops() op allows command-specific event_trigger_ops
selection to be parameterized. When a trigger instance is added, the
reg() op essentially adds that trigger to the triggering event and
arms it, while unreg() does the opposite. The set_filter() function
is used to associate a filter with the trigger - if the command
doesn't specify a set_filter() implementation, the command will ignore
filters.
Each command has an associated trigger_type, which serves double duty,
both as a unique identifier for the command as well as a value that
can be used for setting a trigger mode bit during trigger invocation.
The signature of func() adds a pointer to the event_command struct,
used to invoke those functions, along with a command_data param that
can be passed to the reg/unreg functions. This allows func()
implementations to use command-specific blobs and supports code
re-use.
The event_trigger_ops.func() command corrsponds to the trigger 'probe'
function that gets called when the triggering event is actually
invoked. The other functions are used to list the trigger when
needed, along with a couple mundane book-keeping functions.
This also moves event_file_data() into trace.h so it can be used
outside of trace_events.c.
Link: http://lkml.kernel.org/r/316d95061accdee070aac8e5750afba0192fa5b9.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Idea-by: Steve Rostedt <rostedt@goodmis.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 20:59:24 +07:00
|
|
|
};
|
|
|
|
|
2016-03-04 01:54:55 +07:00
|
|
|
/* Avoid typos */
|
|
|
|
#define ENABLE_EVENT_STR "enable_event"
|
|
|
|
#define DISABLE_EVENT_STR "disable_event"
|
|
|
|
#define ENABLE_HIST_STR "enable_hist"
|
|
|
|
#define DISABLE_HIST_STR "disable_hist"
|
|
|
|
|
|
|
|
struct enable_trigger_data {
|
|
|
|
struct trace_event_file *file;
|
|
|
|
bool enable;
|
|
|
|
bool hist;
|
|
|
|
};
|
|
|
|
|
|
|
|
extern int event_enable_trigger_print(struct seq_file *m,
|
|
|
|
struct event_trigger_ops *ops,
|
|
|
|
struct event_trigger_data *data);
|
|
|
|
extern void event_enable_trigger_free(struct event_trigger_ops *ops,
|
|
|
|
struct event_trigger_data *data);
|
|
|
|
extern int event_enable_trigger_func(struct event_command *cmd_ops,
|
|
|
|
struct trace_event_file *file,
|
|
|
|
char *glob, char *cmd, char *param);
|
|
|
|
extern int event_enable_register_trigger(char *glob,
|
|
|
|
struct event_trigger_ops *ops,
|
|
|
|
struct event_trigger_data *data,
|
|
|
|
struct trace_event_file *file);
|
|
|
|
extern void event_enable_unregister_trigger(char *glob,
|
|
|
|
struct event_trigger_ops *ops,
|
|
|
|
struct event_trigger_data *test,
|
|
|
|
struct trace_event_file *file);
|
2015-12-11 01:50:44 +07:00
|
|
|
extern void trigger_data_free(struct event_trigger_data *data);
|
|
|
|
extern int event_trigger_init(struct event_trigger_ops *ops,
|
|
|
|
struct event_trigger_data *data);
|
|
|
|
extern int trace_event_trigger_enable_disable(struct trace_event_file *file,
|
|
|
|
int trigger_enable);
|
|
|
|
extern void update_cond_flag(struct trace_event_file *file);
|
|
|
|
extern void unregister_trigger(char *glob, struct event_trigger_ops *ops,
|
|
|
|
struct event_trigger_data *test,
|
|
|
|
struct trace_event_file *file);
|
|
|
|
extern int set_trigger_filter(char *filter_str,
|
|
|
|
struct event_trigger_data *trigger_data,
|
|
|
|
struct trace_event_file *file);
|
2016-03-04 01:54:58 +07:00
|
|
|
extern struct event_trigger_data *find_named_trigger(const char *name);
|
|
|
|
extern bool is_named_trigger(struct event_trigger_data *test);
|
|
|
|
extern int save_named_trigger(const char *name,
|
|
|
|
struct event_trigger_data *data);
|
|
|
|
extern void del_named_trigger(struct event_trigger_data *data);
|
|
|
|
extern void pause_named_trigger(struct event_trigger_data *data);
|
|
|
|
extern void unpause_named_trigger(struct event_trigger_data *data);
|
|
|
|
extern void set_named_trigger_data(struct event_trigger_data *data,
|
|
|
|
struct event_trigger_data *named_data);
|
2015-12-11 01:50:44 +07:00
|
|
|
extern int register_event_command(struct event_command *cmd);
|
2016-03-04 01:54:55 +07:00
|
|
|
extern int unregister_event_command(struct event_command *cmd);
|
|
|
|
extern int register_trigger_hist_enable_disable_cmds(void);
|
2015-12-11 01:50:44 +07:00
|
|
|
|
tracing: Add basic event trigger framework
Add a 'trigger' file for each trace event, enabling 'trace event
triggers' to be set for trace events.
'trace event triggers' are patterned after the existing 'ftrace
function triggers' implementation except that triggers are written to
per-event 'trigger' files instead of to a single file such as the
'set_ftrace_filter' used for ftrace function triggers.
The implementation is meant to be entirely separate from ftrace
function triggers, in order to keep the respective implementations
relatively simple and to allow them to diverge.
The event trigger functionality is built on top of SOFT_DISABLE
functionality. It adds a TRIGGER_MODE bit to the ftrace_event_file
flags which is checked when any trace event fires. Triggers set for a
particular event need to be checked regardless of whether that event
is actually enabled or not - getting an event to fire even if it's not
enabled is what's already implemented by SOFT_DISABLE mode, so trigger
mode directly reuses that. Event trigger essentially inherit the soft
disable logic in __ftrace_event_enable_disable() while adding a bit of
logic and trigger reference counting via tm_ref on top of that in a
new trace_event_trigger_enable_disable() function. Because the base
__ftrace_event_enable_disable() code now needs to be invoked from
outside trace_events.c, a wrapper is also added for those usages.
The triggers for an event are actually invoked via a new function,
event_triggers_call(), and code is also added to invoke them for
ftrace_raw_event calls as well as syscall events.
The main part of the patch creates a new trace_events_trigger.c file
to contain the trace event triggers implementation.
The standard open, read, and release file operations are implemented
here.
The open() implementation sets up for the various open modes of the
'trigger' file. It creates and attaches the trigger iterator and sets
up the command parser. If opened for reading set up the trigger
seq_ops.
The read() implementation parses the event trigger written to the
'trigger' file, looks up the trigger command, and passes it along to
that event_command's func() implementation for command-specific
processing.
The release() implementation does whatever cleanup is needed to
release the 'trigger' file, like releasing the parser and trigger
iterator, etc.
A couple of functions for event command registration and
unregistration are added, along with a list to add them to and a mutex
to protect them, as well as an (initially empty) registration function
to add the set of commands that will be added by future commits, and
call to it from the trace event initialization code.
also added are a couple trigger-specific data structures needed for
these implementations such as a trigger iterator and a struct for
trigger-specific data.
A couple structs consisting mostly of function meant to be implemented
in command-specific ways, event_command and event_trigger_ops, are
used by the generic event trigger command implementations. They're
being put into trace.h alongside the other trace_event data structures
and functions, in the expectation that they'll be needed in several
trace_event-related files such as trace_events_trigger.c and
trace_events.c.
The event_command.func() function is meant to be called by the trigger
parsing code in order to add a trigger instance to the corresponding
event. It essentially coordinates adding a live trigger instance to
the event, and arming the triggering the event.
Every event_command func() implementation essentially does the
same thing for any command:
- choose ops - use the value of param to choose either a number or
count version of event_trigger_ops specific to the command
- do the register or unregister of those ops
- associate a filter, if specified, with the triggering event
The reg() and unreg() ops allow command-specific implementations for
event_trigger_op registration and unregistration, and the
get_trigger_ops() op allows command-specific event_trigger_ops
selection to be parameterized. When a trigger instance is added, the
reg() op essentially adds that trigger to the triggering event and
arms it, while unreg() does the opposite. The set_filter() function
is used to associate a filter with the trigger - if the command
doesn't specify a set_filter() implementation, the command will ignore
filters.
Each command has an associated trigger_type, which serves double duty,
both as a unique identifier for the command as well as a value that
can be used for setting a trigger mode bit during trigger invocation.
The signature of func() adds a pointer to the event_command struct,
used to invoke those functions, along with a command_data param that
can be passed to the reg/unreg functions. This allows func()
implementations to use command-specific blobs and supports code
re-use.
The event_trigger_ops.func() command corrsponds to the trigger 'probe'
function that gets called when the triggering event is actually
invoked. The other functions are used to list the trigger when
needed, along with a couple mundane book-keeping functions.
This also moves event_file_data() into trace.h so it can be used
outside of trace_events.c.
Link: http://lkml.kernel.org/r/316d95061accdee070aac8e5750afba0192fa5b9.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Idea-by: Steve Rostedt <rostedt@goodmis.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 20:59:24 +07:00
|
|
|
/**
|
|
|
|
* 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
|
2015-12-11 01:50:45 +07:00
|
|
|
* registered the trigger (see struct event_command) along with
|
|
|
|
* the trace record, rec.
|
tracing: Add basic event trigger framework
Add a 'trigger' file for each trace event, enabling 'trace event
triggers' to be set for trace events.
'trace event triggers' are patterned after the existing 'ftrace
function triggers' implementation except that triggers are written to
per-event 'trigger' files instead of to a single file such as the
'set_ftrace_filter' used for ftrace function triggers.
The implementation is meant to be entirely separate from ftrace
function triggers, in order to keep the respective implementations
relatively simple and to allow them to diverge.
The event trigger functionality is built on top of SOFT_DISABLE
functionality. It adds a TRIGGER_MODE bit to the ftrace_event_file
flags which is checked when any trace event fires. Triggers set for a
particular event need to be checked regardless of whether that event
is actually enabled or not - getting an event to fire even if it's not
enabled is what's already implemented by SOFT_DISABLE mode, so trigger
mode directly reuses that. Event trigger essentially inherit the soft
disable logic in __ftrace_event_enable_disable() while adding a bit of
logic and trigger reference counting via tm_ref on top of that in a
new trace_event_trigger_enable_disable() function. Because the base
__ftrace_event_enable_disable() code now needs to be invoked from
outside trace_events.c, a wrapper is also added for those usages.
The triggers for an event are actually invoked via a new function,
event_triggers_call(), and code is also added to invoke them for
ftrace_raw_event calls as well as syscall events.
The main part of the patch creates a new trace_events_trigger.c file
to contain the trace event triggers implementation.
The standard open, read, and release file operations are implemented
here.
The open() implementation sets up for the various open modes of the
'trigger' file. It creates and attaches the trigger iterator and sets
up the command parser. If opened for reading set up the trigger
seq_ops.
The read() implementation parses the event trigger written to the
'trigger' file, looks up the trigger command, and passes it along to
that event_command's func() implementation for command-specific
processing.
The release() implementation does whatever cleanup is needed to
release the 'trigger' file, like releasing the parser and trigger
iterator, etc.
A couple of functions for event command registration and
unregistration are added, along with a list to add them to and a mutex
to protect them, as well as an (initially empty) registration function
to add the set of commands that will be added by future commits, and
call to it from the trace event initialization code.
also added are a couple trigger-specific data structures needed for
these implementations such as a trigger iterator and a struct for
trigger-specific data.
A couple structs consisting mostly of function meant to be implemented
in command-specific ways, event_command and event_trigger_ops, are
used by the generic event trigger command implementations. They're
being put into trace.h alongside the other trace_event data structures
and functions, in the expectation that they'll be needed in several
trace_event-related files such as trace_events_trigger.c and
trace_events.c.
The event_command.func() function is meant to be called by the trigger
parsing code in order to add a trigger instance to the corresponding
event. It essentially coordinates adding a live trigger instance to
the event, and arming the triggering the event.
Every event_command func() implementation essentially does the
same thing for any command:
- choose ops - use the value of param to choose either a number or
count version of event_trigger_ops specific to the command
- do the register or unregister of those ops
- associate a filter, if specified, with the triggering event
The reg() and unreg() ops allow command-specific implementations for
event_trigger_op registration and unregistration, and the
get_trigger_ops() op allows command-specific event_trigger_ops
selection to be parameterized. When a trigger instance is added, the
reg() op essentially adds that trigger to the triggering event and
arms it, while unreg() does the opposite. The set_filter() function
is used to associate a filter with the trigger - if the command
doesn't specify a set_filter() implementation, the command will ignore
filters.
Each command has an associated trigger_type, which serves double duty,
both as a unique identifier for the command as well as a value that
can be used for setting a trigger mode bit during trigger invocation.
The signature of func() adds a pointer to the event_command struct,
used to invoke those functions, along with a command_data param that
can be passed to the reg/unreg functions. This allows func()
implementations to use command-specific blobs and supports code
re-use.
The event_trigger_ops.func() command corrsponds to the trigger 'probe'
function that gets called when the triggering event is actually
invoked. The other functions are used to list the trigger when
needed, along with a couple mundane book-keeping functions.
This also moves event_file_data() into trace.h so it can be used
outside of trace_events.c.
Link: http://lkml.kernel.org/r/316d95061accdee070aac8e5750afba0192fa5b9.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Idea-by: Steve Rostedt <rostedt@goodmis.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 20:59:24 +07:00
|
|
|
*
|
|
|
|
* @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 {
|
2015-12-11 01:50:45 +07:00
|
|
|
void (*func)(struct event_trigger_data *data,
|
|
|
|
void *rec);
|
tracing: Add basic event trigger framework
Add a 'trigger' file for each trace event, enabling 'trace event
triggers' to be set for trace events.
'trace event triggers' are patterned after the existing 'ftrace
function triggers' implementation except that triggers are written to
per-event 'trigger' files instead of to a single file such as the
'set_ftrace_filter' used for ftrace function triggers.
The implementation is meant to be entirely separate from ftrace
function triggers, in order to keep the respective implementations
relatively simple and to allow them to diverge.
The event trigger functionality is built on top of SOFT_DISABLE
functionality. It adds a TRIGGER_MODE bit to the ftrace_event_file
flags which is checked when any trace event fires. Triggers set for a
particular event need to be checked regardless of whether that event
is actually enabled or not - getting an event to fire even if it's not
enabled is what's already implemented by SOFT_DISABLE mode, so trigger
mode directly reuses that. Event trigger essentially inherit the soft
disable logic in __ftrace_event_enable_disable() while adding a bit of
logic and trigger reference counting via tm_ref on top of that in a
new trace_event_trigger_enable_disable() function. Because the base
__ftrace_event_enable_disable() code now needs to be invoked from
outside trace_events.c, a wrapper is also added for those usages.
The triggers for an event are actually invoked via a new function,
event_triggers_call(), and code is also added to invoke them for
ftrace_raw_event calls as well as syscall events.
The main part of the patch creates a new trace_events_trigger.c file
to contain the trace event triggers implementation.
The standard open, read, and release file operations are implemented
here.
The open() implementation sets up for the various open modes of the
'trigger' file. It creates and attaches the trigger iterator and sets
up the command parser. If opened for reading set up the trigger
seq_ops.
The read() implementation parses the event trigger written to the
'trigger' file, looks up the trigger command, and passes it along to
that event_command's func() implementation for command-specific
processing.
The release() implementation does whatever cleanup is needed to
release the 'trigger' file, like releasing the parser and trigger
iterator, etc.
A couple of functions for event command registration and
unregistration are added, along with a list to add them to and a mutex
to protect them, as well as an (initially empty) registration function
to add the set of commands that will be added by future commits, and
call to it from the trace event initialization code.
also added are a couple trigger-specific data structures needed for
these implementations such as a trigger iterator and a struct for
trigger-specific data.
A couple structs consisting mostly of function meant to be implemented
in command-specific ways, event_command and event_trigger_ops, are
used by the generic event trigger command implementations. They're
being put into trace.h alongside the other trace_event data structures
and functions, in the expectation that they'll be needed in several
trace_event-related files such as trace_events_trigger.c and
trace_events.c.
The event_command.func() function is meant to be called by the trigger
parsing code in order to add a trigger instance to the corresponding
event. It essentially coordinates adding a live trigger instance to
the event, and arming the triggering the event.
Every event_command func() implementation essentially does the
same thing for any command:
- choose ops - use the value of param to choose either a number or
count version of event_trigger_ops specific to the command
- do the register or unregister of those ops
- associate a filter, if specified, with the triggering event
The reg() and unreg() ops allow command-specific implementations for
event_trigger_op registration and unregistration, and the
get_trigger_ops() op allows command-specific event_trigger_ops
selection to be parameterized. When a trigger instance is added, the
reg() op essentially adds that trigger to the triggering event and
arms it, while unreg() does the opposite. The set_filter() function
is used to associate a filter with the trigger - if the command
doesn't specify a set_filter() implementation, the command will ignore
filters.
Each command has an associated trigger_type, which serves double duty,
both as a unique identifier for the command as well as a value that
can be used for setting a trigger mode bit during trigger invocation.
The signature of func() adds a pointer to the event_command struct,
used to invoke those functions, along with a command_data param that
can be passed to the reg/unreg functions. This allows func()
implementations to use command-specific blobs and supports code
re-use.
The event_trigger_ops.func() command corrsponds to the trigger 'probe'
function that gets called when the triggering event is actually
invoked. The other functions are used to list the trigger when
needed, along with a couple mundane book-keeping functions.
This also moves event_file_data() into trace.h so it can be used
outside of trace_events.c.
Link: http://lkml.kernel.org/r/316d95061accdee070aac8e5750afba0192fa5b9.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Idea-by: Steve Rostedt <rostedt@goodmis.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 20:59:24 +07:00
|
|
|
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
|
2015-04-30 01:36:05 +07:00
|
|
|
* enum in include/linux/trace_events.h.
|
tracing: Add basic event trigger framework
Add a 'trigger' file for each trace event, enabling 'trace event
triggers' to be set for trace events.
'trace event triggers' are patterned after the existing 'ftrace
function triggers' implementation except that triggers are written to
per-event 'trigger' files instead of to a single file such as the
'set_ftrace_filter' used for ftrace function triggers.
The implementation is meant to be entirely separate from ftrace
function triggers, in order to keep the respective implementations
relatively simple and to allow them to diverge.
The event trigger functionality is built on top of SOFT_DISABLE
functionality. It adds a TRIGGER_MODE bit to the ftrace_event_file
flags which is checked when any trace event fires. Triggers set for a
particular event need to be checked regardless of whether that event
is actually enabled or not - getting an event to fire even if it's not
enabled is what's already implemented by SOFT_DISABLE mode, so trigger
mode directly reuses that. Event trigger essentially inherit the soft
disable logic in __ftrace_event_enable_disable() while adding a bit of
logic and trigger reference counting via tm_ref on top of that in a
new trace_event_trigger_enable_disable() function. Because the base
__ftrace_event_enable_disable() code now needs to be invoked from
outside trace_events.c, a wrapper is also added for those usages.
The triggers for an event are actually invoked via a new function,
event_triggers_call(), and code is also added to invoke them for
ftrace_raw_event calls as well as syscall events.
The main part of the patch creates a new trace_events_trigger.c file
to contain the trace event triggers implementation.
The standard open, read, and release file operations are implemented
here.
The open() implementation sets up for the various open modes of the
'trigger' file. It creates and attaches the trigger iterator and sets
up the command parser. If opened for reading set up the trigger
seq_ops.
The read() implementation parses the event trigger written to the
'trigger' file, looks up the trigger command, and passes it along to
that event_command's func() implementation for command-specific
processing.
The release() implementation does whatever cleanup is needed to
release the 'trigger' file, like releasing the parser and trigger
iterator, etc.
A couple of functions for event command registration and
unregistration are added, along with a list to add them to and a mutex
to protect them, as well as an (initially empty) registration function
to add the set of commands that will be added by future commits, and
call to it from the trace event initialization code.
also added are a couple trigger-specific data structures needed for
these implementations such as a trigger iterator and a struct for
trigger-specific data.
A couple structs consisting mostly of function meant to be implemented
in command-specific ways, event_command and event_trigger_ops, are
used by the generic event trigger command implementations. They're
being put into trace.h alongside the other trace_event data structures
and functions, in the expectation that they'll be needed in several
trace_event-related files such as trace_events_trigger.c and
trace_events.c.
The event_command.func() function is meant to be called by the trigger
parsing code in order to add a trigger instance to the corresponding
event. It essentially coordinates adding a live trigger instance to
the event, and arming the triggering the event.
Every event_command func() implementation essentially does the
same thing for any command:
- choose ops - use the value of param to choose either a number or
count version of event_trigger_ops specific to the command
- do the register or unregister of those ops
- associate a filter, if specified, with the triggering event
The reg() and unreg() ops allow command-specific implementations for
event_trigger_op registration and unregistration, and the
get_trigger_ops() op allows command-specific event_trigger_ops
selection to be parameterized. When a trigger instance is added, the
reg() op essentially adds that trigger to the triggering event and
arms it, while unreg() does the opposite. The set_filter() function
is used to associate a filter with the trigger - if the command
doesn't specify a set_filter() implementation, the command will ignore
filters.
Each command has an associated trigger_type, which serves double duty,
both as a unique identifier for the command as well as a value that
can be used for setting a trigger mode bit during trigger invocation.
The signature of func() adds a pointer to the event_command struct,
used to invoke those functions, along with a command_data param that
can be passed to the reg/unreg functions. This allows func()
implementations to use command-specific blobs and supports code
re-use.
The event_trigger_ops.func() command corrsponds to the trigger 'probe'
function that gets called when the triggering event is actually
invoked. The other functions are used to list the trigger when
needed, along with a couple mundane book-keeping functions.
This also moves event_file_data() into trace.h so it can be used
outside of trace_events.c.
Link: http://lkml.kernel.org/r/316d95061accdee070aac8e5750afba0192fa5b9.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Idea-by: Steve Rostedt <rostedt@goodmis.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 20:59:24 +07:00
|
|
|
*
|
2016-02-23 03:55:09 +07:00
|
|
|
* @flags: See the enum event_command_flags below.
|
2015-12-11 01:50:48 +07:00
|
|
|
*
|
2015-12-11 01:50:49 +07:00
|
|
|
* All the methods below, except for @set_filter() and @unreg_all(),
|
|
|
|
* must be implemented.
|
tracing: Add basic event trigger framework
Add a 'trigger' file for each trace event, enabling 'trace event
triggers' to be set for trace events.
'trace event triggers' are patterned after the existing 'ftrace
function triggers' implementation except that triggers are written to
per-event 'trigger' files instead of to a single file such as the
'set_ftrace_filter' used for ftrace function triggers.
The implementation is meant to be entirely separate from ftrace
function triggers, in order to keep the respective implementations
relatively simple and to allow them to diverge.
The event trigger functionality is built on top of SOFT_DISABLE
functionality. It adds a TRIGGER_MODE bit to the ftrace_event_file
flags which is checked when any trace event fires. Triggers set for a
particular event need to be checked regardless of whether that event
is actually enabled or not - getting an event to fire even if it's not
enabled is what's already implemented by SOFT_DISABLE mode, so trigger
mode directly reuses that. Event trigger essentially inherit the soft
disable logic in __ftrace_event_enable_disable() while adding a bit of
logic and trigger reference counting via tm_ref on top of that in a
new trace_event_trigger_enable_disable() function. Because the base
__ftrace_event_enable_disable() code now needs to be invoked from
outside trace_events.c, a wrapper is also added for those usages.
The triggers for an event are actually invoked via a new function,
event_triggers_call(), and code is also added to invoke them for
ftrace_raw_event calls as well as syscall events.
The main part of the patch creates a new trace_events_trigger.c file
to contain the trace event triggers implementation.
The standard open, read, and release file operations are implemented
here.
The open() implementation sets up for the various open modes of the
'trigger' file. It creates and attaches the trigger iterator and sets
up the command parser. If opened for reading set up the trigger
seq_ops.
The read() implementation parses the event trigger written to the
'trigger' file, looks up the trigger command, and passes it along to
that event_command's func() implementation for command-specific
processing.
The release() implementation does whatever cleanup is needed to
release the 'trigger' file, like releasing the parser and trigger
iterator, etc.
A couple of functions for event command registration and
unregistration are added, along with a list to add them to and a mutex
to protect them, as well as an (initially empty) registration function
to add the set of commands that will be added by future commits, and
call to it from the trace event initialization code.
also added are a couple trigger-specific data structures needed for
these implementations such as a trigger iterator and a struct for
trigger-specific data.
A couple structs consisting mostly of function meant to be implemented
in command-specific ways, event_command and event_trigger_ops, are
used by the generic event trigger command implementations. They're
being put into trace.h alongside the other trace_event data structures
and functions, in the expectation that they'll be needed in several
trace_event-related files such as trace_events_trigger.c and
trace_events.c.
The event_command.func() function is meant to be called by the trigger
parsing code in order to add a trigger instance to the corresponding
event. It essentially coordinates adding a live trigger instance to
the event, and arming the triggering the event.
Every event_command func() implementation essentially does the
same thing for any command:
- choose ops - use the value of param to choose either a number or
count version of event_trigger_ops specific to the command
- do the register or unregister of those ops
- associate a filter, if specified, with the triggering event
The reg() and unreg() ops allow command-specific implementations for
event_trigger_op registration and unregistration, and the
get_trigger_ops() op allows command-specific event_trigger_ops
selection to be parameterized. When a trigger instance is added, the
reg() op essentially adds that trigger to the triggering event and
arms it, while unreg() does the opposite. The set_filter() function
is used to associate a filter with the trigger - if the command
doesn't specify a set_filter() implementation, the command will ignore
filters.
Each command has an associated trigger_type, which serves double duty,
both as a unique identifier for the command as well as a value that
can be used for setting a trigger mode bit during trigger invocation.
The signature of func() adds a pointer to the event_command struct,
used to invoke those functions, along with a command_data param that
can be passed to the reg/unreg functions. This allows func()
implementations to use command-specific blobs and supports code
re-use.
The event_trigger_ops.func() command corrsponds to the trigger 'probe'
function that gets called when the triggering event is actually
invoked. The other functions are used to list the trigger when
needed, along with a couple mundane book-keeping functions.
This also moves event_file_data() into trace.h so it can be used
outside of trace_events.c.
Link: http://lkml.kernel.org/r/316d95061accdee070aac8e5750afba0192fa5b9.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Idea-by: Steve Rostedt <rostedt@goodmis.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 20:59:24 +07:00
|
|
|
*
|
|
|
|
* @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).
|
|
|
|
*
|
2015-12-11 01:50:49 +07:00
|
|
|
* @unreg_all: An optional function called to remove all the triggers
|
|
|
|
* from the list of triggers associated with the event. Called
|
|
|
|
* when a trigger file is opened in truncate mode.
|
|
|
|
*
|
tracing: Add basic event trigger framework
Add a 'trigger' file for each trace event, enabling 'trace event
triggers' to be set for trace events.
'trace event triggers' are patterned after the existing 'ftrace
function triggers' implementation except that triggers are written to
per-event 'trigger' files instead of to a single file such as the
'set_ftrace_filter' used for ftrace function triggers.
The implementation is meant to be entirely separate from ftrace
function triggers, in order to keep the respective implementations
relatively simple and to allow them to diverge.
The event trigger functionality is built on top of SOFT_DISABLE
functionality. It adds a TRIGGER_MODE bit to the ftrace_event_file
flags which is checked when any trace event fires. Triggers set for a
particular event need to be checked regardless of whether that event
is actually enabled or not - getting an event to fire even if it's not
enabled is what's already implemented by SOFT_DISABLE mode, so trigger
mode directly reuses that. Event trigger essentially inherit the soft
disable logic in __ftrace_event_enable_disable() while adding a bit of
logic and trigger reference counting via tm_ref on top of that in a
new trace_event_trigger_enable_disable() function. Because the base
__ftrace_event_enable_disable() code now needs to be invoked from
outside trace_events.c, a wrapper is also added for those usages.
The triggers for an event are actually invoked via a new function,
event_triggers_call(), and code is also added to invoke them for
ftrace_raw_event calls as well as syscall events.
The main part of the patch creates a new trace_events_trigger.c file
to contain the trace event triggers implementation.
The standard open, read, and release file operations are implemented
here.
The open() implementation sets up for the various open modes of the
'trigger' file. It creates and attaches the trigger iterator and sets
up the command parser. If opened for reading set up the trigger
seq_ops.
The read() implementation parses the event trigger written to the
'trigger' file, looks up the trigger command, and passes it along to
that event_command's func() implementation for command-specific
processing.
The release() implementation does whatever cleanup is needed to
release the 'trigger' file, like releasing the parser and trigger
iterator, etc.
A couple of functions for event command registration and
unregistration are added, along with a list to add them to and a mutex
to protect them, as well as an (initially empty) registration function
to add the set of commands that will be added by future commits, and
call to it from the trace event initialization code.
also added are a couple trigger-specific data structures needed for
these implementations such as a trigger iterator and a struct for
trigger-specific data.
A couple structs consisting mostly of function meant to be implemented
in command-specific ways, event_command and event_trigger_ops, are
used by the generic event trigger command implementations. They're
being put into trace.h alongside the other trace_event data structures
and functions, in the expectation that they'll be needed in several
trace_event-related files such as trace_events_trigger.c and
trace_events.c.
The event_command.func() function is meant to be called by the trigger
parsing code in order to add a trigger instance to the corresponding
event. It essentially coordinates adding a live trigger instance to
the event, and arming the triggering the event.
Every event_command func() implementation essentially does the
same thing for any command:
- choose ops - use the value of param to choose either a number or
count version of event_trigger_ops specific to the command
- do the register or unregister of those ops
- associate a filter, if specified, with the triggering event
The reg() and unreg() ops allow command-specific implementations for
event_trigger_op registration and unregistration, and the
get_trigger_ops() op allows command-specific event_trigger_ops
selection to be parameterized. When a trigger instance is added, the
reg() op essentially adds that trigger to the triggering event and
arms it, while unreg() does the opposite. The set_filter() function
is used to associate a filter with the trigger - if the command
doesn't specify a set_filter() implementation, the command will ignore
filters.
Each command has an associated trigger_type, which serves double duty,
both as a unique identifier for the command as well as a value that
can be used for setting a trigger mode bit during trigger invocation.
The signature of func() adds a pointer to the event_command struct,
used to invoke those functions, along with a command_data param that
can be passed to the reg/unreg functions. This allows func()
implementations to use command-specific blobs and supports code
re-use.
The event_trigger_ops.func() command corrsponds to the trigger 'probe'
function that gets called when the triggering event is actually
invoked. The other functions are used to list the trigger when
needed, along with a couple mundane book-keeping functions.
This also moves event_file_data() into trace.h so it can be used
outside of trace_events.c.
Link: http://lkml.kernel.org/r/316d95061accdee070aac8e5750afba0192fa5b9.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Idea-by: Steve Rostedt <rostedt@goodmis.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 20:59:24 +07:00
|
|
|
* @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;
|
2016-02-23 03:55:09 +07:00
|
|
|
int flags;
|
tracing: Add basic event trigger framework
Add a 'trigger' file for each trace event, enabling 'trace event
triggers' to be set for trace events.
'trace event triggers' are patterned after the existing 'ftrace
function triggers' implementation except that triggers are written to
per-event 'trigger' files instead of to a single file such as the
'set_ftrace_filter' used for ftrace function triggers.
The implementation is meant to be entirely separate from ftrace
function triggers, in order to keep the respective implementations
relatively simple and to allow them to diverge.
The event trigger functionality is built on top of SOFT_DISABLE
functionality. It adds a TRIGGER_MODE bit to the ftrace_event_file
flags which is checked when any trace event fires. Triggers set for a
particular event need to be checked regardless of whether that event
is actually enabled or not - getting an event to fire even if it's not
enabled is what's already implemented by SOFT_DISABLE mode, so trigger
mode directly reuses that. Event trigger essentially inherit the soft
disable logic in __ftrace_event_enable_disable() while adding a bit of
logic and trigger reference counting via tm_ref on top of that in a
new trace_event_trigger_enable_disable() function. Because the base
__ftrace_event_enable_disable() code now needs to be invoked from
outside trace_events.c, a wrapper is also added for those usages.
The triggers for an event are actually invoked via a new function,
event_triggers_call(), and code is also added to invoke them for
ftrace_raw_event calls as well as syscall events.
The main part of the patch creates a new trace_events_trigger.c file
to contain the trace event triggers implementation.
The standard open, read, and release file operations are implemented
here.
The open() implementation sets up for the various open modes of the
'trigger' file. It creates and attaches the trigger iterator and sets
up the command parser. If opened for reading set up the trigger
seq_ops.
The read() implementation parses the event trigger written to the
'trigger' file, looks up the trigger command, and passes it along to
that event_command's func() implementation for command-specific
processing.
The release() implementation does whatever cleanup is needed to
release the 'trigger' file, like releasing the parser and trigger
iterator, etc.
A couple of functions for event command registration and
unregistration are added, along with a list to add them to and a mutex
to protect them, as well as an (initially empty) registration function
to add the set of commands that will be added by future commits, and
call to it from the trace event initialization code.
also added are a couple trigger-specific data structures needed for
these implementations such as a trigger iterator and a struct for
trigger-specific data.
A couple structs consisting mostly of function meant to be implemented
in command-specific ways, event_command and event_trigger_ops, are
used by the generic event trigger command implementations. They're
being put into trace.h alongside the other trace_event data structures
and functions, in the expectation that they'll be needed in several
trace_event-related files such as trace_events_trigger.c and
trace_events.c.
The event_command.func() function is meant to be called by the trigger
parsing code in order to add a trigger instance to the corresponding
event. It essentially coordinates adding a live trigger instance to
the event, and arming the triggering the event.
Every event_command func() implementation essentially does the
same thing for any command:
- choose ops - use the value of param to choose either a number or
count version of event_trigger_ops specific to the command
- do the register or unregister of those ops
- associate a filter, if specified, with the triggering event
The reg() and unreg() ops allow command-specific implementations for
event_trigger_op registration and unregistration, and the
get_trigger_ops() op allows command-specific event_trigger_ops
selection to be parameterized. When a trigger instance is added, the
reg() op essentially adds that trigger to the triggering event and
arms it, while unreg() does the opposite. The set_filter() function
is used to associate a filter with the trigger - if the command
doesn't specify a set_filter() implementation, the command will ignore
filters.
Each command has an associated trigger_type, which serves double duty,
both as a unique identifier for the command as well as a value that
can be used for setting a trigger mode bit during trigger invocation.
The signature of func() adds a pointer to the event_command struct,
used to invoke those functions, along with a command_data param that
can be passed to the reg/unreg functions. This allows func()
implementations to use command-specific blobs and supports code
re-use.
The event_trigger_ops.func() command corrsponds to the trigger 'probe'
function that gets called when the triggering event is actually
invoked. The other functions are used to list the trigger when
needed, along with a couple mundane book-keeping functions.
This also moves event_file_data() into trace.h so it can be used
outside of trace_events.c.
Link: http://lkml.kernel.org/r/316d95061accdee070aac8e5750afba0192fa5b9.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Idea-by: Steve Rostedt <rostedt@goodmis.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 20:59:24 +07:00
|
|
|
int (*func)(struct event_command *cmd_ops,
|
2015-05-05 21:09:53 +07:00
|
|
|
struct trace_event_file *file,
|
tracing: Add basic event trigger framework
Add a 'trigger' file for each trace event, enabling 'trace event
triggers' to be set for trace events.
'trace event triggers' are patterned after the existing 'ftrace
function triggers' implementation except that triggers are written to
per-event 'trigger' files instead of to a single file such as the
'set_ftrace_filter' used for ftrace function triggers.
The implementation is meant to be entirely separate from ftrace
function triggers, in order to keep the respective implementations
relatively simple and to allow them to diverge.
The event trigger functionality is built on top of SOFT_DISABLE
functionality. It adds a TRIGGER_MODE bit to the ftrace_event_file
flags which is checked when any trace event fires. Triggers set for a
particular event need to be checked regardless of whether that event
is actually enabled or not - getting an event to fire even if it's not
enabled is what's already implemented by SOFT_DISABLE mode, so trigger
mode directly reuses that. Event trigger essentially inherit the soft
disable logic in __ftrace_event_enable_disable() while adding a bit of
logic and trigger reference counting via tm_ref on top of that in a
new trace_event_trigger_enable_disable() function. Because the base
__ftrace_event_enable_disable() code now needs to be invoked from
outside trace_events.c, a wrapper is also added for those usages.
The triggers for an event are actually invoked via a new function,
event_triggers_call(), and code is also added to invoke them for
ftrace_raw_event calls as well as syscall events.
The main part of the patch creates a new trace_events_trigger.c file
to contain the trace event triggers implementation.
The standard open, read, and release file operations are implemented
here.
The open() implementation sets up for the various open modes of the
'trigger' file. It creates and attaches the trigger iterator and sets
up the command parser. If opened for reading set up the trigger
seq_ops.
The read() implementation parses the event trigger written to the
'trigger' file, looks up the trigger command, and passes it along to
that event_command's func() implementation for command-specific
processing.
The release() implementation does whatever cleanup is needed to
release the 'trigger' file, like releasing the parser and trigger
iterator, etc.
A couple of functions for event command registration and
unregistration are added, along with a list to add them to and a mutex
to protect them, as well as an (initially empty) registration function
to add the set of commands that will be added by future commits, and
call to it from the trace event initialization code.
also added are a couple trigger-specific data structures needed for
these implementations such as a trigger iterator and a struct for
trigger-specific data.
A couple structs consisting mostly of function meant to be implemented
in command-specific ways, event_command and event_trigger_ops, are
used by the generic event trigger command implementations. They're
being put into trace.h alongside the other trace_event data structures
and functions, in the expectation that they'll be needed in several
trace_event-related files such as trace_events_trigger.c and
trace_events.c.
The event_command.func() function is meant to be called by the trigger
parsing code in order to add a trigger instance to the corresponding
event. It essentially coordinates adding a live trigger instance to
the event, and arming the triggering the event.
Every event_command func() implementation essentially does the
same thing for any command:
- choose ops - use the value of param to choose either a number or
count version of event_trigger_ops specific to the command
- do the register or unregister of those ops
- associate a filter, if specified, with the triggering event
The reg() and unreg() ops allow command-specific implementations for
event_trigger_op registration and unregistration, and the
get_trigger_ops() op allows command-specific event_trigger_ops
selection to be parameterized. When a trigger instance is added, the
reg() op essentially adds that trigger to the triggering event and
arms it, while unreg() does the opposite. The set_filter() function
is used to associate a filter with the trigger - if the command
doesn't specify a set_filter() implementation, the command will ignore
filters.
Each command has an associated trigger_type, which serves double duty,
both as a unique identifier for the command as well as a value that
can be used for setting a trigger mode bit during trigger invocation.
The signature of func() adds a pointer to the event_command struct,
used to invoke those functions, along with a command_data param that
can be passed to the reg/unreg functions. This allows func()
implementations to use command-specific blobs and supports code
re-use.
The event_trigger_ops.func() command corrsponds to the trigger 'probe'
function that gets called when the triggering event is actually
invoked. The other functions are used to list the trigger when
needed, along with a couple mundane book-keeping functions.
This also moves event_file_data() into trace.h so it can be used
outside of trace_events.c.
Link: http://lkml.kernel.org/r/316d95061accdee070aac8e5750afba0192fa5b9.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Idea-by: Steve Rostedt <rostedt@goodmis.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 20:59:24 +07:00
|
|
|
char *glob, char *cmd, char *params);
|
|
|
|
int (*reg)(char *glob,
|
|
|
|
struct event_trigger_ops *ops,
|
|
|
|
struct event_trigger_data *data,
|
2015-05-05 21:09:53 +07:00
|
|
|
struct trace_event_file *file);
|
tracing: Add basic event trigger framework
Add a 'trigger' file for each trace event, enabling 'trace event
triggers' to be set for trace events.
'trace event triggers' are patterned after the existing 'ftrace
function triggers' implementation except that triggers are written to
per-event 'trigger' files instead of to a single file such as the
'set_ftrace_filter' used for ftrace function triggers.
The implementation is meant to be entirely separate from ftrace
function triggers, in order to keep the respective implementations
relatively simple and to allow them to diverge.
The event trigger functionality is built on top of SOFT_DISABLE
functionality. It adds a TRIGGER_MODE bit to the ftrace_event_file
flags which is checked when any trace event fires. Triggers set for a
particular event need to be checked regardless of whether that event
is actually enabled or not - getting an event to fire even if it's not
enabled is what's already implemented by SOFT_DISABLE mode, so trigger
mode directly reuses that. Event trigger essentially inherit the soft
disable logic in __ftrace_event_enable_disable() while adding a bit of
logic and trigger reference counting via tm_ref on top of that in a
new trace_event_trigger_enable_disable() function. Because the base
__ftrace_event_enable_disable() code now needs to be invoked from
outside trace_events.c, a wrapper is also added for those usages.
The triggers for an event are actually invoked via a new function,
event_triggers_call(), and code is also added to invoke them for
ftrace_raw_event calls as well as syscall events.
The main part of the patch creates a new trace_events_trigger.c file
to contain the trace event triggers implementation.
The standard open, read, and release file operations are implemented
here.
The open() implementation sets up for the various open modes of the
'trigger' file. It creates and attaches the trigger iterator and sets
up the command parser. If opened for reading set up the trigger
seq_ops.
The read() implementation parses the event trigger written to the
'trigger' file, looks up the trigger command, and passes it along to
that event_command's func() implementation for command-specific
processing.
The release() implementation does whatever cleanup is needed to
release the 'trigger' file, like releasing the parser and trigger
iterator, etc.
A couple of functions for event command registration and
unregistration are added, along with a list to add them to and a mutex
to protect them, as well as an (initially empty) registration function
to add the set of commands that will be added by future commits, and
call to it from the trace event initialization code.
also added are a couple trigger-specific data structures needed for
these implementations such as a trigger iterator and a struct for
trigger-specific data.
A couple structs consisting mostly of function meant to be implemented
in command-specific ways, event_command and event_trigger_ops, are
used by the generic event trigger command implementations. They're
being put into trace.h alongside the other trace_event data structures
and functions, in the expectation that they'll be needed in several
trace_event-related files such as trace_events_trigger.c and
trace_events.c.
The event_command.func() function is meant to be called by the trigger
parsing code in order to add a trigger instance to the corresponding
event. It essentially coordinates adding a live trigger instance to
the event, and arming the triggering the event.
Every event_command func() implementation essentially does the
same thing for any command:
- choose ops - use the value of param to choose either a number or
count version of event_trigger_ops specific to the command
- do the register or unregister of those ops
- associate a filter, if specified, with the triggering event
The reg() and unreg() ops allow command-specific implementations for
event_trigger_op registration and unregistration, and the
get_trigger_ops() op allows command-specific event_trigger_ops
selection to be parameterized. When a trigger instance is added, the
reg() op essentially adds that trigger to the triggering event and
arms it, while unreg() does the opposite. The set_filter() function
is used to associate a filter with the trigger - if the command
doesn't specify a set_filter() implementation, the command will ignore
filters.
Each command has an associated trigger_type, which serves double duty,
both as a unique identifier for the command as well as a value that
can be used for setting a trigger mode bit during trigger invocation.
The signature of func() adds a pointer to the event_command struct,
used to invoke those functions, along with a command_data param that
can be passed to the reg/unreg functions. This allows func()
implementations to use command-specific blobs and supports code
re-use.
The event_trigger_ops.func() command corrsponds to the trigger 'probe'
function that gets called when the triggering event is actually
invoked. The other functions are used to list the trigger when
needed, along with a couple mundane book-keeping functions.
This also moves event_file_data() into trace.h so it can be used
outside of trace_events.c.
Link: http://lkml.kernel.org/r/316d95061accdee070aac8e5750afba0192fa5b9.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Idea-by: Steve Rostedt <rostedt@goodmis.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 20:59:24 +07:00
|
|
|
void (*unreg)(char *glob,
|
|
|
|
struct event_trigger_ops *ops,
|
|
|
|
struct event_trigger_data *data,
|
2015-05-05 21:09:53 +07:00
|
|
|
struct trace_event_file *file);
|
2015-12-11 01:50:49 +07:00
|
|
|
void (*unreg_all)(struct trace_event_file *file);
|
tracing: Add basic event trigger framework
Add a 'trigger' file for each trace event, enabling 'trace event
triggers' to be set for trace events.
'trace event triggers' are patterned after the existing 'ftrace
function triggers' implementation except that triggers are written to
per-event 'trigger' files instead of to a single file such as the
'set_ftrace_filter' used for ftrace function triggers.
The implementation is meant to be entirely separate from ftrace
function triggers, in order to keep the respective implementations
relatively simple and to allow them to diverge.
The event trigger functionality is built on top of SOFT_DISABLE
functionality. It adds a TRIGGER_MODE bit to the ftrace_event_file
flags which is checked when any trace event fires. Triggers set for a
particular event need to be checked regardless of whether that event
is actually enabled or not - getting an event to fire even if it's not
enabled is what's already implemented by SOFT_DISABLE mode, so trigger
mode directly reuses that. Event trigger essentially inherit the soft
disable logic in __ftrace_event_enable_disable() while adding a bit of
logic and trigger reference counting via tm_ref on top of that in a
new trace_event_trigger_enable_disable() function. Because the base
__ftrace_event_enable_disable() code now needs to be invoked from
outside trace_events.c, a wrapper is also added for those usages.
The triggers for an event are actually invoked via a new function,
event_triggers_call(), and code is also added to invoke them for
ftrace_raw_event calls as well as syscall events.
The main part of the patch creates a new trace_events_trigger.c file
to contain the trace event triggers implementation.
The standard open, read, and release file operations are implemented
here.
The open() implementation sets up for the various open modes of the
'trigger' file. It creates and attaches the trigger iterator and sets
up the command parser. If opened for reading set up the trigger
seq_ops.
The read() implementation parses the event trigger written to the
'trigger' file, looks up the trigger command, and passes it along to
that event_command's func() implementation for command-specific
processing.
The release() implementation does whatever cleanup is needed to
release the 'trigger' file, like releasing the parser and trigger
iterator, etc.
A couple of functions for event command registration and
unregistration are added, along with a list to add them to and a mutex
to protect them, as well as an (initially empty) registration function
to add the set of commands that will be added by future commits, and
call to it from the trace event initialization code.
also added are a couple trigger-specific data structures needed for
these implementations such as a trigger iterator and a struct for
trigger-specific data.
A couple structs consisting mostly of function meant to be implemented
in command-specific ways, event_command and event_trigger_ops, are
used by the generic event trigger command implementations. They're
being put into trace.h alongside the other trace_event data structures
and functions, in the expectation that they'll be needed in several
trace_event-related files such as trace_events_trigger.c and
trace_events.c.
The event_command.func() function is meant to be called by the trigger
parsing code in order to add a trigger instance to the corresponding
event. It essentially coordinates adding a live trigger instance to
the event, and arming the triggering the event.
Every event_command func() implementation essentially does the
same thing for any command:
- choose ops - use the value of param to choose either a number or
count version of event_trigger_ops specific to the command
- do the register or unregister of those ops
- associate a filter, if specified, with the triggering event
The reg() and unreg() ops allow command-specific implementations for
event_trigger_op registration and unregistration, and the
get_trigger_ops() op allows command-specific event_trigger_ops
selection to be parameterized. When a trigger instance is added, the
reg() op essentially adds that trigger to the triggering event and
arms it, while unreg() does the opposite. The set_filter() function
is used to associate a filter with the trigger - if the command
doesn't specify a set_filter() implementation, the command will ignore
filters.
Each command has an associated trigger_type, which serves double duty,
both as a unique identifier for the command as well as a value that
can be used for setting a trigger mode bit during trigger invocation.
The signature of func() adds a pointer to the event_command struct,
used to invoke those functions, along with a command_data param that
can be passed to the reg/unreg functions. This allows func()
implementations to use command-specific blobs and supports code
re-use.
The event_trigger_ops.func() command corrsponds to the trigger 'probe'
function that gets called when the triggering event is actually
invoked. The other functions are used to list the trigger when
needed, along with a couple mundane book-keeping functions.
This also moves event_file_data() into trace.h so it can be used
outside of trace_events.c.
Link: http://lkml.kernel.org/r/316d95061accdee070aac8e5750afba0192fa5b9.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Idea-by: Steve Rostedt <rostedt@goodmis.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 20:59:24 +07:00
|
|
|
int (*set_filter)(char *filter_str,
|
|
|
|
struct event_trigger_data *data,
|
2015-05-05 21:09:53 +07:00
|
|
|
struct trace_event_file *file);
|
tracing: Add basic event trigger framework
Add a 'trigger' file for each trace event, enabling 'trace event
triggers' to be set for trace events.
'trace event triggers' are patterned after the existing 'ftrace
function triggers' implementation except that triggers are written to
per-event 'trigger' files instead of to a single file such as the
'set_ftrace_filter' used for ftrace function triggers.
The implementation is meant to be entirely separate from ftrace
function triggers, in order to keep the respective implementations
relatively simple and to allow them to diverge.
The event trigger functionality is built on top of SOFT_DISABLE
functionality. It adds a TRIGGER_MODE bit to the ftrace_event_file
flags which is checked when any trace event fires. Triggers set for a
particular event need to be checked regardless of whether that event
is actually enabled or not - getting an event to fire even if it's not
enabled is what's already implemented by SOFT_DISABLE mode, so trigger
mode directly reuses that. Event trigger essentially inherit the soft
disable logic in __ftrace_event_enable_disable() while adding a bit of
logic and trigger reference counting via tm_ref on top of that in a
new trace_event_trigger_enable_disable() function. Because the base
__ftrace_event_enable_disable() code now needs to be invoked from
outside trace_events.c, a wrapper is also added for those usages.
The triggers for an event are actually invoked via a new function,
event_triggers_call(), and code is also added to invoke them for
ftrace_raw_event calls as well as syscall events.
The main part of the patch creates a new trace_events_trigger.c file
to contain the trace event triggers implementation.
The standard open, read, and release file operations are implemented
here.
The open() implementation sets up for the various open modes of the
'trigger' file. It creates and attaches the trigger iterator and sets
up the command parser. If opened for reading set up the trigger
seq_ops.
The read() implementation parses the event trigger written to the
'trigger' file, looks up the trigger command, and passes it along to
that event_command's func() implementation for command-specific
processing.
The release() implementation does whatever cleanup is needed to
release the 'trigger' file, like releasing the parser and trigger
iterator, etc.
A couple of functions for event command registration and
unregistration are added, along with a list to add them to and a mutex
to protect them, as well as an (initially empty) registration function
to add the set of commands that will be added by future commits, and
call to it from the trace event initialization code.
also added are a couple trigger-specific data structures needed for
these implementations such as a trigger iterator and a struct for
trigger-specific data.
A couple structs consisting mostly of function meant to be implemented
in command-specific ways, event_command and event_trigger_ops, are
used by the generic event trigger command implementations. They're
being put into trace.h alongside the other trace_event data structures
and functions, in the expectation that they'll be needed in several
trace_event-related files such as trace_events_trigger.c and
trace_events.c.
The event_command.func() function is meant to be called by the trigger
parsing code in order to add a trigger instance to the corresponding
event. It essentially coordinates adding a live trigger instance to
the event, and arming the triggering the event.
Every event_command func() implementation essentially does the
same thing for any command:
- choose ops - use the value of param to choose either a number or
count version of event_trigger_ops specific to the command
- do the register or unregister of those ops
- associate a filter, if specified, with the triggering event
The reg() and unreg() ops allow command-specific implementations for
event_trigger_op registration and unregistration, and the
get_trigger_ops() op allows command-specific event_trigger_ops
selection to be parameterized. When a trigger instance is added, the
reg() op essentially adds that trigger to the triggering event and
arms it, while unreg() does the opposite. The set_filter() function
is used to associate a filter with the trigger - if the command
doesn't specify a set_filter() implementation, the command will ignore
filters.
Each command has an associated trigger_type, which serves double duty,
both as a unique identifier for the command as well as a value that
can be used for setting a trigger mode bit during trigger invocation.
The signature of func() adds a pointer to the event_command struct,
used to invoke those functions, along with a command_data param that
can be passed to the reg/unreg functions. This allows func()
implementations to use command-specific blobs and supports code
re-use.
The event_trigger_ops.func() command corrsponds to the trigger 'probe'
function that gets called when the triggering event is actually
invoked. The other functions are used to list the trigger when
needed, along with a couple mundane book-keeping functions.
This also moves event_file_data() into trace.h so it can be used
outside of trace_events.c.
Link: http://lkml.kernel.org/r/316d95061accdee070aac8e5750afba0192fa5b9.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Idea-by: Steve Rostedt <rostedt@goodmis.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 20:59:24 +07:00
|
|
|
struct event_trigger_ops *(*get_trigger_ops)(char *cmd, char *param);
|
|
|
|
};
|
|
|
|
|
2016-02-23 03:55:09 +07:00
|
|
|
/**
|
|
|
|
* enum event_command_flags - flags for struct event_command
|
|
|
|
*
|
|
|
|
* @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.
|
|
|
|
*
|
|
|
|
* @NEEDS_REC: A flag that says whether or not this command needs
|
|
|
|
* access to the trace record in order to perform its function,
|
|
|
|
* regardless of whether or not it has a filter associated with
|
|
|
|
* it (filters make a trigger require access to the trace record
|
|
|
|
* but are not always present).
|
|
|
|
*/
|
|
|
|
enum event_command_flags {
|
|
|
|
EVENT_CMD_FL_POST_TRIGGER = 1,
|
|
|
|
EVENT_CMD_FL_NEEDS_REC = 2,
|
|
|
|
};
|
|
|
|
|
|
|
|
static inline bool event_command_post_trigger(struct event_command *cmd_ops)
|
|
|
|
{
|
|
|
|
return cmd_ops->flags & EVENT_CMD_FL_POST_TRIGGER;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool event_command_needs_rec(struct event_command *cmd_ops)
|
|
|
|
{
|
|
|
|
return cmd_ops->flags & EVENT_CMD_FL_NEEDS_REC;
|
|
|
|
}
|
|
|
|
|
2015-05-05 21:09:53 +07:00
|
|
|
extern int trace_event_enable_disable(struct trace_event_file *file,
|
tracing: Add basic event trigger framework
Add a 'trigger' file for each trace event, enabling 'trace event
triggers' to be set for trace events.
'trace event triggers' are patterned after the existing 'ftrace
function triggers' implementation except that triggers are written to
per-event 'trigger' files instead of to a single file such as the
'set_ftrace_filter' used for ftrace function triggers.
The implementation is meant to be entirely separate from ftrace
function triggers, in order to keep the respective implementations
relatively simple and to allow them to diverge.
The event trigger functionality is built on top of SOFT_DISABLE
functionality. It adds a TRIGGER_MODE bit to the ftrace_event_file
flags which is checked when any trace event fires. Triggers set for a
particular event need to be checked regardless of whether that event
is actually enabled or not - getting an event to fire even if it's not
enabled is what's already implemented by SOFT_DISABLE mode, so trigger
mode directly reuses that. Event trigger essentially inherit the soft
disable logic in __ftrace_event_enable_disable() while adding a bit of
logic and trigger reference counting via tm_ref on top of that in a
new trace_event_trigger_enable_disable() function. Because the base
__ftrace_event_enable_disable() code now needs to be invoked from
outside trace_events.c, a wrapper is also added for those usages.
The triggers for an event are actually invoked via a new function,
event_triggers_call(), and code is also added to invoke them for
ftrace_raw_event calls as well as syscall events.
The main part of the patch creates a new trace_events_trigger.c file
to contain the trace event triggers implementation.
The standard open, read, and release file operations are implemented
here.
The open() implementation sets up for the various open modes of the
'trigger' file. It creates and attaches the trigger iterator and sets
up the command parser. If opened for reading set up the trigger
seq_ops.
The read() implementation parses the event trigger written to the
'trigger' file, looks up the trigger command, and passes it along to
that event_command's func() implementation for command-specific
processing.
The release() implementation does whatever cleanup is needed to
release the 'trigger' file, like releasing the parser and trigger
iterator, etc.
A couple of functions for event command registration and
unregistration are added, along with a list to add them to and a mutex
to protect them, as well as an (initially empty) registration function
to add the set of commands that will be added by future commits, and
call to it from the trace event initialization code.
also added are a couple trigger-specific data structures needed for
these implementations such as a trigger iterator and a struct for
trigger-specific data.
A couple structs consisting mostly of function meant to be implemented
in command-specific ways, event_command and event_trigger_ops, are
used by the generic event trigger command implementations. They're
being put into trace.h alongside the other trace_event data structures
and functions, in the expectation that they'll be needed in several
trace_event-related files such as trace_events_trigger.c and
trace_events.c.
The event_command.func() function is meant to be called by the trigger
parsing code in order to add a trigger instance to the corresponding
event. It essentially coordinates adding a live trigger instance to
the event, and arming the triggering the event.
Every event_command func() implementation essentially does the
same thing for any command:
- choose ops - use the value of param to choose either a number or
count version of event_trigger_ops specific to the command
- do the register or unregister of those ops
- associate a filter, if specified, with the triggering event
The reg() and unreg() ops allow command-specific implementations for
event_trigger_op registration and unregistration, and the
get_trigger_ops() op allows command-specific event_trigger_ops
selection to be parameterized. When a trigger instance is added, the
reg() op essentially adds that trigger to the triggering event and
arms it, while unreg() does the opposite. The set_filter() function
is used to associate a filter with the trigger - if the command
doesn't specify a set_filter() implementation, the command will ignore
filters.
Each command has an associated trigger_type, which serves double duty,
both as a unique identifier for the command as well as a value that
can be used for setting a trigger mode bit during trigger invocation.
The signature of func() adds a pointer to the event_command struct,
used to invoke those functions, along with a command_data param that
can be passed to the reg/unreg functions. This allows func()
implementations to use command-specific blobs and supports code
re-use.
The event_trigger_ops.func() command corrsponds to the trigger 'probe'
function that gets called when the triggering event is actually
invoked. The other functions are used to list the trigger when
needed, along with a couple mundane book-keeping functions.
This also moves event_file_data() into trace.h so it can be used
outside of trace_events.c.
Link: http://lkml.kernel.org/r/316d95061accdee070aac8e5750afba0192fa5b9.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Idea-by: Steve Rostedt <rostedt@goodmis.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 20:59:24 +07:00
|
|
|
int enable, int soft_disable);
|
2013-10-24 20:59:26 +07:00
|
|
|
extern int tracing_alloc_snapshot(void);
|
tracing: Add basic event trigger framework
Add a 'trigger' file for each trace event, enabling 'trace event
triggers' to be set for trace events.
'trace event triggers' are patterned after the existing 'ftrace
function triggers' implementation except that triggers are written to
per-event 'trigger' files instead of to a single file such as the
'set_ftrace_filter' used for ftrace function triggers.
The implementation is meant to be entirely separate from ftrace
function triggers, in order to keep the respective implementations
relatively simple and to allow them to diverge.
The event trigger functionality is built on top of SOFT_DISABLE
functionality. It adds a TRIGGER_MODE bit to the ftrace_event_file
flags which is checked when any trace event fires. Triggers set for a
particular event need to be checked regardless of whether that event
is actually enabled or not - getting an event to fire even if it's not
enabled is what's already implemented by SOFT_DISABLE mode, so trigger
mode directly reuses that. Event trigger essentially inherit the soft
disable logic in __ftrace_event_enable_disable() while adding a bit of
logic and trigger reference counting via tm_ref on top of that in a
new trace_event_trigger_enable_disable() function. Because the base
__ftrace_event_enable_disable() code now needs to be invoked from
outside trace_events.c, a wrapper is also added for those usages.
The triggers for an event are actually invoked via a new function,
event_triggers_call(), and code is also added to invoke them for
ftrace_raw_event calls as well as syscall events.
The main part of the patch creates a new trace_events_trigger.c file
to contain the trace event triggers implementation.
The standard open, read, and release file operations are implemented
here.
The open() implementation sets up for the various open modes of the
'trigger' file. It creates and attaches the trigger iterator and sets
up the command parser. If opened for reading set up the trigger
seq_ops.
The read() implementation parses the event trigger written to the
'trigger' file, looks up the trigger command, and passes it along to
that event_command's func() implementation for command-specific
processing.
The release() implementation does whatever cleanup is needed to
release the 'trigger' file, like releasing the parser and trigger
iterator, etc.
A couple of functions for event command registration and
unregistration are added, along with a list to add them to and a mutex
to protect them, as well as an (initially empty) registration function
to add the set of commands that will be added by future commits, and
call to it from the trace event initialization code.
also added are a couple trigger-specific data structures needed for
these implementations such as a trigger iterator and a struct for
trigger-specific data.
A couple structs consisting mostly of function meant to be implemented
in command-specific ways, event_command and event_trigger_ops, are
used by the generic event trigger command implementations. They're
being put into trace.h alongside the other trace_event data structures
and functions, in the expectation that they'll be needed in several
trace_event-related files such as trace_events_trigger.c and
trace_events.c.
The event_command.func() function is meant to be called by the trigger
parsing code in order to add a trigger instance to the corresponding
event. It essentially coordinates adding a live trigger instance to
the event, and arming the triggering the event.
Every event_command func() implementation essentially does the
same thing for any command:
- choose ops - use the value of param to choose either a number or
count version of event_trigger_ops specific to the command
- do the register or unregister of those ops
- associate a filter, if specified, with the triggering event
The reg() and unreg() ops allow command-specific implementations for
event_trigger_op registration and unregistration, and the
get_trigger_ops() op allows command-specific event_trigger_ops
selection to be parameterized. When a trigger instance is added, the
reg() op essentially adds that trigger to the triggering event and
arms it, while unreg() does the opposite. The set_filter() function
is used to associate a filter with the trigger - if the command
doesn't specify a set_filter() implementation, the command will ignore
filters.
Each command has an associated trigger_type, which serves double duty,
both as a unique identifier for the command as well as a value that
can be used for setting a trigger mode bit during trigger invocation.
The signature of func() adds a pointer to the event_command struct,
used to invoke those functions, along with a command_data param that
can be passed to the reg/unreg functions. This allows func()
implementations to use command-specific blobs and supports code
re-use.
The event_trigger_ops.func() command corrsponds to the trigger 'probe'
function that gets called when the triggering event is actually
invoked. The other functions are used to list the trigger when
needed, along with a couple mundane book-keeping functions.
This also moves event_file_data() into trace.h so it can be used
outside of trace_events.c.
Link: http://lkml.kernel.org/r/316d95061accdee070aac8e5750afba0192fa5b9.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Idea-by: Steve Rostedt <rostedt@goodmis.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 20:59:24 +07:00
|
|
|
|
2009-03-13 01:19:25 +07:00
|
|
|
extern const char *__start___trace_bprintk_fmt[];
|
|
|
|
extern const char *__stop___trace_bprintk_fmt[];
|
|
|
|
|
2013-07-13 04:07:27 +07:00
|
|
|
extern const char *__start___tracepoint_str[];
|
|
|
|
extern const char *__stop___tracepoint_str[];
|
|
|
|
|
2015-09-30 05:21:35 +07:00
|
|
|
void trace_printk_control(bool enabled);
|
tracing: Add percpu buffers for trace_printk()
Currently, trace_printk() uses a single buffer to write into
to calculate the size and format needed to save the trace. To
do this safely in an SMP environment, a spin_lock() is taken
to only allow one writer at a time to the buffer. But this could
also affect what is being traced, and add synchronization that
would not be there otherwise.
Ideally, using percpu buffers would be useful, but since trace_printk()
is only used in development, having per cpu buffers for something
never used is a waste of space. Thus, the use of the trace_bprintk()
format section is changed to be used for static fmts as well as dynamic ones.
Then at boot up, we can check if the section that holds the trace_printk
formats is non-empty, and if it does contain something, then we
know a trace_printk() has been added to the kernel. At this time
the trace_printk per cpu buffers are allocated. A check is also
done at module load time in case a module is added that contains a
trace_printk().
Once the buffers are allocated, they are never freed. If you use
a trace_printk() then you should know what you are doing.
A buffer is made for each type of context:
normal
softirq
irq
nmi
The context is checked and the appropriate buffer is used.
This allows for totally lockless usage of trace_printk(),
and they no longer even disable interrupts.
Requested-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2011-09-23 01:01:55 +07:00
|
|
|
void trace_printk_init_buffers(void);
|
2012-10-11 21:15:05 +07:00
|
|
|
void trace_printk_start_comm(void);
|
2013-03-15 02:03:53 +07:00
|
|
|
int trace_keep_overwrite(struct tracer *tracer, u32 mask, int set);
|
2012-05-12 00:29:49 +07:00
|
|
|
int set_tracer_flag(struct trace_array *tr, unsigned int mask, int enabled);
|
tracing: Add percpu buffers for trace_printk()
Currently, trace_printk() uses a single buffer to write into
to calculate the size and format needed to save the trace. To
do this safely in an SMP environment, a spin_lock() is taken
to only allow one writer at a time to the buffer. But this could
also affect what is being traced, and add synchronization that
would not be there otherwise.
Ideally, using percpu buffers would be useful, but since trace_printk()
is only used in development, having per cpu buffers for something
never used is a waste of space. Thus, the use of the trace_bprintk()
format section is changed to be used for static fmts as well as dynamic ones.
Then at boot up, we can check if the section that holds the trace_printk
formats is non-empty, and if it does contain something, then we
know a trace_printk() has been added to the kernel. At this time
the trace_printk per cpu buffers are allocated. A check is also
done at module load time in case a module is added that contains a
trace_printk().
Once the buffers are allocated, they are never freed. If you use
a trace_printk() then you should know what you are doing.
A buffer is made for each type of context:
normal
softirq
irq
nmi
The context is checked and the appropriate buffer is used.
This allows for totally lockless usage of trace_printk(),
and they no longer even disable interrupts.
Requested-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2011-09-23 01:01:55 +07:00
|
|
|
|
2013-03-09 12:40:58 +07:00
|
|
|
/*
|
|
|
|
* Normal trace_printk() and friends allocates special buffers
|
|
|
|
* to do the manipulation, as well as saves the print formats
|
|
|
|
* into sections to display. But the trace infrastructure wants
|
|
|
|
* to use these without the added overhead at the price of being
|
|
|
|
* a bit slower (used mainly for warnings, where we don't care
|
|
|
|
* about performance). The internal_trace_puts() is for such
|
|
|
|
* a purpose.
|
|
|
|
*/
|
|
|
|
#define internal_trace_puts(str) __trace_puts(_THIS_IP_, str, strlen(str))
|
|
|
|
|
2009-09-13 06:26:21 +07:00
|
|
|
#undef FTRACE_ENTRY
|
2012-02-15 21:51:53 +07:00
|
|
|
#define FTRACE_ENTRY(call, struct_name, id, tstruct, print, filter) \
|
2015-05-05 22:45:27 +07:00
|
|
|
extern struct trace_event_call \
|
2014-04-08 05:39:20 +07:00
|
|
|
__aligned(4) event_##call;
|
2009-09-13 06:26:21 +07:00
|
|
|
#undef FTRACE_ENTRY_DUP
|
2012-02-15 21:51:53 +07:00
|
|
|
#define FTRACE_ENTRY_DUP(call, struct_name, id, tstruct, print, filter) \
|
|
|
|
FTRACE_ENTRY(call, struct_name, id, PARAMS(tstruct), PARAMS(print), \
|
|
|
|
filter)
|
2016-06-29 17:56:48 +07:00
|
|
|
#undef FTRACE_ENTRY_PACKED
|
|
|
|
#define FTRACE_ENTRY_PACKED(call, struct_name, id, tstruct, print, filter) \
|
|
|
|
FTRACE_ENTRY(call, struct_name, id, PARAMS(tstruct), PARAMS(print), \
|
|
|
|
filter)
|
|
|
|
|
2009-09-13 06:26:21 +07:00
|
|
|
#include "trace_entries.h"
|
2009-03-31 12:48:49 +07:00
|
|
|
|
2012-04-13 15:52:59 +07:00
|
|
|
#if defined(CONFIG_PERF_EVENTS) && defined(CONFIG_FUNCTION_TRACER)
|
2015-05-05 22:45:27 +07:00
|
|
|
int perf_ftrace_event_register(struct trace_event_call *call,
|
2012-02-15 21:51:52 +07:00
|
|
|
enum trace_reg type, void *data);
|
|
|
|
#else
|
|
|
|
#define perf_ftrace_event_register NULL
|
2012-04-13 15:52:59 +07:00
|
|
|
#endif
|
2012-02-15 21:51:52 +07:00
|
|
|
|
2014-12-13 08:05:10 +07:00
|
|
|
#ifdef CONFIG_FTRACE_SYSCALLS
|
|
|
|
void init_ftrace_syscalls(void);
|
2015-12-11 01:50:46 +07:00
|
|
|
const char *get_syscall_name(int syscall);
|
2014-12-13 08:05:10 +07:00
|
|
|
#else
|
|
|
|
static inline void init_ftrace_syscalls(void) { }
|
2015-12-11 01:50:46 +07:00
|
|
|
static inline const char *get_syscall_name(int syscall)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
2014-12-13 08:05:10 +07:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_EVENT_TRACING
|
|
|
|
void trace_event_init(void);
|
tracing: Add TRACE_DEFINE_ENUM() macro to map enums to their values
Several tracepoints use the helper functions __print_symbolic() or
__print_flags() and pass in enums that do the mapping between the
binary data stored and the value to print. This works well for reading
the ASCII trace files, but when the data is read via userspace tools
such as perf and trace-cmd, the conversion of the binary value to a
human string format is lost if an enum is used, as userspace does not
have access to what the ENUM is.
For example, the tracepoint trace_tlb_flush() has:
__print_symbolic(REC->reason,
{ TLB_FLUSH_ON_TASK_SWITCH, "flush on task switch" },
{ TLB_REMOTE_SHOOTDOWN, "remote shootdown" },
{ TLB_LOCAL_SHOOTDOWN, "local shootdown" },
{ TLB_LOCAL_MM_SHOOTDOWN, "local mm shootdown" })
Which maps the enum values to the strings they represent. But perf and
trace-cmd do no know what value TLB_LOCAL_MM_SHOOTDOWN is, and would
not be able to map it.
With TRACE_DEFINE_ENUM(), developers can place these in the event header
files and ftrace will convert the enums to their values:
By adding:
TRACE_DEFINE_ENUM(TLB_FLUSH_ON_TASK_SWITCH);
TRACE_DEFINE_ENUM(TLB_REMOTE_SHOOTDOWN);
TRACE_DEFINE_ENUM(TLB_LOCAL_SHOOTDOWN);
TRACE_DEFINE_ENUM(TLB_LOCAL_MM_SHOOTDOWN);
$ cat /sys/kernel/debug/tracing/events/tlb/tlb_flush/format
[...]
__print_symbolic(REC->reason,
{ 0, "flush on task switch" },
{ 1, "remote shootdown" },
{ 2, "local shootdown" },
{ 3, "local mm shootdown" })
The above is what userspace expects to see, and tools do not need to
be modified to parse them.
Link: http://lkml.kernel.org/r/20150403013802.220157513@goodmis.org
Cc: Guilherme Cox <cox@computer.org>
Cc: Tony Luck <tony.luck@gmail.com>
Cc: Xie XiuQi <xiexiuqi@huawei.com>
Acked-by: Namhyung Kim <namhyung@kernel.org>
Reviewed-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Tested-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2015-03-25 04:58:09 +07:00
|
|
|
void trace_event_enum_update(struct trace_enum_map **map, int len);
|
2014-12-13 08:05:10 +07:00
|
|
|
#else
|
|
|
|
static inline void __init trace_event_init(void) { }
|
2015-06-26 05:19:37 +07:00
|
|
|
static inline void trace_event_enum_update(struct trace_enum_map **map, int len) { }
|
2014-12-13 08:05:10 +07:00
|
|
|
#endif
|
|
|
|
|
2014-12-13 10:27:10 +07:00
|
|
|
extern struct trace_iterator *tracepoint_print_iter;
|
2014-12-13 08:05:10 +07:00
|
|
|
|
2008-05-13 02:20:42 +07:00
|
|
|
#endif /* _LINUX_KERNEL_TRACE_H */
|