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 07:59:29 -06:00
|
|
|
|
2008-05-12 13:20:42 -06:00
|
|
|
#ifndef _LINUX_KERNEL_TRACE_H
|
|
|
|
#define _LINUX_KERNEL_TRACE_H
|
|
|
|
|
|
|
|
#include <linux/fs.h>
|
2011-07-26 17:09:06 -06:00
|
|
|
#include <linux/atomic.h>
|
2008-05-12 13:20:42 -06:00
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/clocksource.h>
|
2008-09-29 21:02:41 -06: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-12 13:20:57 -06:00
|
|
|
#include <linux/mmiotrace.h>
|
2009-09-12 17:26:21 -06:00
|
|
|
#include <linux/tracepoint.h>
|
2008-09-23 04:32:08 -06:00
|
|
|
#include <linux/ftrace.h>
|
2009-09-09 11:22:48 -06: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 10:59:57 -06:00
|
|
|
#include <linux/trace_seq.h>
|
2009-04-13 09:20:49 -06:00
|
|
|
#include <linux/ftrace_event.h>
|
2014-04-07 16:39:20 -06:00
|
|
|
#include <linux/compiler.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 10:59:57 -06:00
|
|
|
|
2012-08-08 12:48:20 -06:00
|
|
|
#ifdef CONFIG_FTRACE_SYSCALLS
|
|
|
|
#include <asm/unistd.h> /* For NR_SYSCALLS */
|
|
|
|
#include <asm/syscall.h> /* some archs define it here */
|
|
|
|
#endif
|
|
|
|
|
2008-05-23 13:37:28 -06:00
|
|
|
enum trace_type {
|
|
|
|
__TRACE_FIRST_TYPE = 0,
|
|
|
|
|
|
|
|
TRACE_FN,
|
|
|
|
TRACE_CTX,
|
|
|
|
TRACE_WAKE,
|
|
|
|
TRACE_STACK,
|
2008-08-01 10:26:41 -06:00
|
|
|
TRACE_PRINT,
|
2009-03-12 11:24:49 -06: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-12 13:20:57 -06:00
|
|
|
TRACE_MMIO_RW,
|
|
|
|
TRACE_MMIO_MAP,
|
2008-11-12 13:24:24 -07:00
|
|
|
TRACE_BRANCH,
|
2008-11-25 16:57:25 -07:00
|
|
|
TRACE_GRAPH_RET,
|
|
|
|
TRACE_GRAPH_ENT,
|
2008-11-22 04: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 07:06:27 -07:00
|
|
|
TRACE_BLK,
|
2013-03-08 19:02:34 -07:00
|
|
|
TRACE_BPUTS,
|
2008-05-23 13:37:28 -06:00
|
|
|
|
2008-12-23 21:24:12 -07:00
|
|
|
__TRACE_LAST_TYPE,
|
2008-05-23 13:37:28 -06:00
|
|
|
};
|
|
|
|
|
2008-05-12 13:20:42 -06:00
|
|
|
|
2009-09-12 17:17:15 -06:00
|
|
|
#undef __field
|
|
|
|
#define __field(type, item) type item;
|
2008-05-12 13:20:51 -06:00
|
|
|
|
2009-09-12 17:22:23 -06:00
|
|
|
#undef __field_struct
|
|
|
|
#define __field_struct(type, item) __field(type, item)
|
2008-05-12 13:20:51 -06:00
|
|
|
|
2009-09-12 17:22:23 -06:00
|
|
|
#undef __field_desc
|
|
|
|
#define __field_desc(type, container, item)
|
2008-11-22 04:28:47 -07:00
|
|
|
|
2009-09-12 17:17:15 -06:00
|
|
|
#undef __array
|
|
|
|
#define __array(type, item, size) type item[size];
|
2009-03-06 09:21:47 -07:00
|
|
|
|
2009-09-12 17:22:23 -06:00
|
|
|
#undef __array_desc
|
|
|
|
#define __array_desc(type, container, item, size)
|
2008-09-29 21:02:42 -06:00
|
|
|
|
2009-09-12 17:17:15 -06:00
|
|
|
#undef __dynamic_array
|
|
|
|
#define __dynamic_array(type, item) type item[];
|
2008-09-29 21:02:42 -06:00
|
|
|
|
2009-09-12 17:17:15 -06:00
|
|
|
#undef F_STRUCT
|
|
|
|
#define F_STRUCT(args...) args
|
2008-11-11 15:24:42 -07:00
|
|
|
|
2009-09-12 17:17:15 -06:00
|
|
|
#undef FTRACE_ENTRY
|
2012-02-15 07:51:53 -07:00
|
|
|
#define FTRACE_ENTRY(name, struct_name, id, tstruct, print, filter) \
|
|
|
|
struct struct_name { \
|
|
|
|
struct trace_entry ent; \
|
|
|
|
tstruct \
|
2009-09-12 17:17:15 -06:00
|
|
|
}
|
2008-09-29 21:02:42 -06:00
|
|
|
|
2009-09-12 17:17:15 -06:00
|
|
|
#undef TP_ARGS
|
|
|
|
#define TP_ARGS(args...) args
|
2008-11-11 22:14:40 -07:00
|
|
|
|
2009-09-12 17:17:15 -06:00
|
|
|
#undef FTRACE_ENTRY_DUP
|
2012-02-15 07:51:53 -07:00
|
|
|
#define FTRACE_ENTRY_DUP(name, name_struct, id, tstruct, printk, filter)
|
2008-11-25 01:24:15 -07:00
|
|
|
|
2012-02-15 07:51:51 -07:00
|
|
|
#undef FTRACE_ENTRY_REG
|
2012-02-15 07: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 07:51:51 -07:00
|
|
|
|
2009-09-12 17:17:15 -06:00
|
|
|
#include "trace_entries.h"
|
2008-12-29 14:42:23 -07:00
|
|
|
|
2009-09-12 17:17:15 -06:00
|
|
|
/*
|
|
|
|
* syscalls are special, and need special handling, this is why
|
|
|
|
* they are not included in trace_entries.h
|
|
|
|
*/
|
2009-03-13 08:42:11 -06: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 00:14:59 -07:00
|
|
|
long ret;
|
2009-03-13 08:42:11 -06: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-12 11:17:08 -06:00
|
|
|
struct kprobe_trace_entry_head {
|
2009-08-13 14:35:11 -06: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-12 11:17:08 -06:00
|
|
|
struct kretprobe_trace_entry_head {
|
2009-08-13 14:35:11 -06:00
|
|
|
struct trace_entry ent;
|
|
|
|
unsigned long func;
|
|
|
|
unsigned long ret_ip;
|
|
|
|
};
|
|
|
|
|
2008-09-16 13:02:27 -06:00
|
|
|
/*
|
|
|
|
* trace_flag_type is an enumeration that holds different
|
|
|
|
* states when a trace occurs. These are:
|
2008-10-24 07:42:59 -06:00
|
|
|
* IRQS_OFF - interrupts were disabled
|
2009-03-06 09:52:03 -07:00
|
|
|
* IRQS_NOSUPPORT - arch does not support irqs_disabled_flags
|
2009-09-09 19:34:19 -06:00
|
|
|
* NEED_RESCHED - reschedule is requested
|
2008-10-24 07:42:59 -06:00
|
|
|
* HARDIRQ - inside an interrupt handler
|
|
|
|
* SOFTIRQ - inside a softirq handler
|
2008-09-16 13:02:27 -06:00
|
|
|
*/
|
|
|
|
enum trace_flag_type {
|
|
|
|
TRACE_FLAG_IRQS_OFF = 0x01,
|
2008-10-24 07:42:59 -06:00
|
|
|
TRACE_FLAG_IRQS_NOSUPPORT = 0x02,
|
|
|
|
TRACE_FLAG_NEED_RESCHED = 0x04,
|
|
|
|
TRACE_FLAG_HARDIRQ = 0x08,
|
|
|
|
TRACE_FLAG_SOFTIRQ = 0x10,
|
2013-10-04 09:28:26 -06:00
|
|
|
TRACE_FLAG_PREEMPT_RESCHED = 0x20,
|
2008-09-16 13:02:27 -06:00
|
|
|
};
|
|
|
|
|
2008-09-16 13:06:42 -06:00
|
|
|
#define TRACE_BUF_SIZE 1024
|
2008-05-12 13:20:42 -06:00
|
|
|
|
2012-05-11 11:29:49 -06:00
|
|
|
struct trace_array;
|
|
|
|
|
2008-05-12 13:20:42 -06: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-01 20:20:19 -07:00
|
|
|
void *buffer_page; /* ring buffer spare */
|
2008-05-12 13:20:45 -06:00
|
|
|
|
2012-02-02 13:00:41 -07:00
|
|
|
unsigned long entries;
|
2008-05-12 13:20:42 -06: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 09:06:29 -06:00
|
|
|
unsigned long skipped_entries;
|
2008-05-12 13:20:42 -06:00
|
|
|
cycle_t preempt_timestamp;
|
|
|
|
pid_t pid;
|
2012-03-13 17:02:19 -06:00
|
|
|
kuid_t uid;
|
2008-05-12 13:20:42 -06:00
|
|
|
char comm[TASK_COMM_LEN];
|
|
|
|
};
|
|
|
|
|
2012-05-11 11:29:49 -06:00
|
|
|
struct tracer;
|
|
|
|
|
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 07:24:35 -07:00
|
|
|
struct trace_buffer {
|
|
|
|
struct trace_array *tr;
|
|
|
|
struct ring_buffer *buffer;
|
|
|
|
struct trace_array_cpu __percpu *data;
|
|
|
|
cycle_t time_start;
|
|
|
|
int cpu;
|
|
|
|
};
|
|
|
|
|
2008-05-12 13:20:42 -06: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-03 21:09:03 -06:00
|
|
|
struct list_head list;
|
2012-08-03 14:10:49 -06: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 07: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-05 16:25:02 -07:00
|
|
|
bool allocated_snapshot;
|
2014-01-14 09: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 07:24:35 -07:00
|
|
|
#endif
|
2014-01-14 08: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-22 13:50:28 -07:00
|
|
|
int buffer_disabled;
|
2012-08-08 12:48:20 -06:00
|
|
|
#ifdef CONFIG_FTRACE_SYSCALLS
|
|
|
|
int sys_refcount_enter;
|
|
|
|
int sys_refcount_exit;
|
2013-11-11 09:47:06 -07:00
|
|
|
struct ftrace_event_file __rcu *enter_syscall_files[NR_syscalls];
|
|
|
|
struct ftrace_event_file __rcu *exit_syscall_files[NR_syscalls];
|
2012-08-08 12:48:20 -06:00
|
|
|
#endif
|
2012-05-11 11:29:49 -06:00
|
|
|
int stop_count;
|
|
|
|
int clock_id;
|
|
|
|
struct tracer *current_trace;
|
2012-05-03 21:09:03 -06:00
|
|
|
unsigned int flags;
|
2012-05-11 11:29:49 -06:00
|
|
|
raw_spinlock_t start_lock;
|
2012-05-03 21:09:03 -06:00
|
|
|
struct dentry *dir;
|
2012-05-11 11:29:49 -06:00
|
|
|
struct dentry *options;
|
|
|
|
struct dentry *percpu_dir;
|
2012-05-03 21:09:03 -06:00
|
|
|
struct dentry *event_dir;
|
|
|
|
struct list_head systems;
|
|
|
|
struct list_head events;
|
2013-08-08 10:47:45 -06:00
|
|
|
cpumask_var_t tracing_cpumask; /* only trace on set CPUs */
|
2013-03-06 13:27:24 -07:00
|
|
|
int ref;
|
2013-11-07 18:08:58 -07:00
|
|
|
#ifdef CONFIG_FUNCTION_TRACER
|
|
|
|
struct ftrace_ops *ops;
|
|
|
|
/* function tracing enabled */
|
|
|
|
int function_enabled;
|
|
|
|
#endif
|
2008-05-12 13:20:42 -06:00
|
|
|
};
|
|
|
|
|
2012-05-03 21:09:03 -06:00
|
|
|
enum {
|
|
|
|
TRACE_ARRAY_FL_GLOBAL = (1 << 0)
|
|
|
|
};
|
|
|
|
|
|
|
|
extern struct list_head ftrace_trace_arrays;
|
|
|
|
|
2013-07-01 20:37:54 -06:00
|
|
|
extern struct mutex trace_types_lock;
|
|
|
|
|
2013-07-02 13:30:53 -06:00
|
|
|
extern int trace_array_get(struct trace_array *tr);
|
|
|
|
extern void trace_array_put(struct trace_array *tr);
|
|
|
|
|
2012-05-03 21:09:03 -06: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-10 11:53:50 -06:00
|
|
|
if (list_empty(&ftrace_trace_arrays))
|
2014-06-05 16:35:17 -06:00
|
|
|
return NULL;
|
|
|
|
|
2012-05-03 21:09:03 -06:00
|
|
|
tr = list_entry(ftrace_trace_arrays.prev,
|
|
|
|
typeof(*tr), list);
|
|
|
|
WARN_ON(!(tr->flags & TRACE_ARRAY_FL_GLOBAL));
|
|
|
|
return tr;
|
|
|
|
}
|
|
|
|
|
2008-10-01 08:52:51 -06: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 04:28:47 -07:00
|
|
|
IF_ASSIGN(var, ent, struct userstack_entry, TRACE_USER_STACK);\
|
2008-10-01 08:52:51 -06:00
|
|
|
IF_ASSIGN(var, ent, struct print_entry, TRACE_PRINT); \
|
2009-03-12 11:24:49 -06:00
|
|
|
IF_ASSIGN(var, ent, struct bprint_entry, TRACE_BPRINT); \
|
2013-03-08 19:02:34 -07:00
|
|
|
IF_ASSIGN(var, ent, struct bputs_entry, TRACE_BPUTS); \
|
2008-10-01 08:52:51 -06: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-12 13:24:24 -07:00
|
|
|
IF_ASSIGN(var, ent, struct trace_branch, TRACE_BRANCH); \
|
2008-11-25 16: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 08:52:51 -06:00
|
|
|
__ftrace_bad_type(); \
|
|
|
|
} while (0)
|
2008-09-29 12:18:34 -06:00
|
|
|
|
2008-11-17 11: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 09: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-17 11: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 09:52:03 -07:00
|
|
|
struct tracer_opt *opts;
|
2008-11-17 11:23:42 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
/* Makes more easy to define a tracer opt */
|
|
|
|
#define TRACER_OPT(s, b) .name = #s, .bit = b
|
|
|
|
|
2009-01-08 11:03:56 -07:00
|
|
|
|
2009-02-10 18:25:00 -07:00
|
|
|
/**
|
|
|
|
* struct tracer - a specific tracer and its callbacks to interact with debugfs
|
|
|
|
* @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
|
|
|
|
* @start: called when tracing is unpaused (echo 1 > tracing_enabled)
|
|
|
|
* @stop: called when tracing is paused (echo 0 > tracing_enabled)
|
2014-07-18 05:17:27 -06:00
|
|
|
* @update_thresh: called when tracing_thresh is updated
|
2009-02-10 18: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 07:06:24 -07:00
|
|
|
* @pipe_close: called when the trace_pipe file is released
|
2009-02-10 18: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-12 13:20:42 -06:00
|
|
|
*/
|
|
|
|
struct tracer {
|
|
|
|
const char *name;
|
2008-11-15 21:57:26 -07:00
|
|
|
int (*init)(struct trace_array *tr);
|
2008-05-12 13:20:42 -06: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-05 14:05:44 -07:00
|
|
|
void (*start)(struct trace_array *tr);
|
|
|
|
void (*stop)(struct trace_array *tr);
|
2014-07-18 05:17:27 -06:00
|
|
|
int (*update_thresh)(struct trace_array *tr);
|
2008-05-12 13:20:42 -06:00
|
|
|
void (*open)(struct trace_iterator *iter);
|
2008-05-12 13:21:01 -06:00
|
|
|
void (*pipe_open)(struct trace_iterator *iter);
|
2008-05-12 13:20:42 -06:00
|
|
|
void (*close)(struct trace_iterator *iter);
|
2009-12-07 07:06:24 -07:00
|
|
|
void (*pipe_close)(struct trace_iterator *iter);
|
2008-05-12 13:21:01 -06:00
|
|
|
ssize_t (*read)(struct trace_iterator *iter,
|
|
|
|
struct file *filp, char __user *ubuf,
|
|
|
|
size_t cnt, loff_t *ppos);
|
2009-02-08 23: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-12 13:20:44 -06:00
|
|
|
#ifdef CONFIG_FTRACE_STARTUP_TEST
|
|
|
|
int (*selftest)(struct tracer *trace,
|
|
|
|
struct trace_array *tr);
|
|
|
|
#endif
|
2008-11-25 01:12:31 -07:00
|
|
|
void (*print_header)(struct seq_file *m);
|
2008-09-29 12:18:34 -06:00
|
|
|
enum print_line_t (*print_line)(struct trace_iterator *iter);
|
2008-11-17 11:23:42 -07:00
|
|
|
/* If you handled the flag setting, return 0 */
|
2014-01-10 09:13:54 -07:00
|
|
|
int (*set_flag)(struct trace_array *tr,
|
|
|
|
u32 old_flags, u32 bit, int set);
|
2013-03-14 13:03:53 -06:00
|
|
|
/* Return 0 if OK with change, else return non-zero */
|
2014-01-10 15:51:01 -07:00
|
|
|
int (*flag_changed)(struct trace_array *tr,
|
2013-03-14 13:03:53 -06:00
|
|
|
u32 mask, int set);
|
2008-05-12 13:20:42 -06:00
|
|
|
struct tracer *next;
|
2009-03-06 09:52:03 -07:00
|
|
|
struct tracer_flags *flags;
|
2014-01-14 06:52:35 -07:00
|
|
|
int enabled;
|
2012-10-02 02:27:10 -06:00
|
|
|
bool print_max;
|
2013-11-06 20: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 07:24:35 -07:00
|
|
|
#ifdef CONFIG_TRACER_MAX_TRACE
|
2012-10-02 02:27:10 -06: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 07:24:35 -07:00
|
|
|
#endif
|
2008-05-12 13:20:42 -06:00
|
|
|
};
|
|
|
|
|
2009-03-02 12:04:40 -07:00
|
|
|
|
2011-06-14 17:02:29 -06:00
|
|
|
/* Only current can touch trace_recursion */
|
|
|
|
|
2012-11-02 15:47:21 -06: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-02 15:32:25 -06:00
|
|
|
enum {
|
2012-11-02 16:33:05 -06: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-02 15:47:21 -06:00
|
|
|
TRACE_FTRACE_NMI_BIT,
|
|
|
|
TRACE_FTRACE_IRQ_BIT,
|
|
|
|
TRACE_FTRACE_SIRQ_BIT,
|
2012-11-02 15:32:25 -06:00
|
|
|
|
2014-01-10 15:01:58 -07:00
|
|
|
/* INTERNAL_BITs must be greater than FTRACE_BITs */
|
2012-11-02 15:47:21 -06:00
|
|
|
TRACE_INTERNAL_BIT,
|
|
|
|
TRACE_INTERNAL_NMI_BIT,
|
|
|
|
TRACE_INTERNAL_IRQ_BIT,
|
|
|
|
TRACE_INTERNAL_SIRQ_BIT,
|
|
|
|
|
2012-11-02 15:32:25 -06:00
|
|
|
TRACE_CONTROL_BIT,
|
2012-02-15 07:51:48 -07:00
|
|
|
|
2011-06-14 17:02:29 -06: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-02 15:32:25 -06:00
|
|
|
TRACE_IRQ_BIT,
|
|
|
|
};
|
2011-06-14 17:02:29 -06:00
|
|
|
|
2012-11-02 15:32:25 -06: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-14 17:02:29 -06:00
|
|
|
|
2012-11-02 15:47:21 -06: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-27 18:46:14 -06: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-05 13: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-05 14: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 07:24:35 -07:00
|
|
|
void tracing_reset(struct trace_buffer *buf, int cpu);
|
|
|
|
void tracing_reset_online_cpus(struct trace_buffer *buf);
|
2009-05-06 19:54:09 -06:00
|
|
|
void tracing_reset_current(int cpu);
|
2013-03-04 21:26:06 -07:00
|
|
|
void tracing_reset_all_online_cpus(void);
|
2008-05-12 13:20:42 -06:00
|
|
|
int tracing_open_generic(struct inode *inode, struct file *filp);
|
2013-10-18 18:15:54 -06:00
|
|
|
bool tracing_is_disabled(void);
|
2009-03-26 17:25:38 -06:00
|
|
|
struct dentry *trace_create_file(const char *name,
|
2011-07-24 02:33:43 -06:00
|
|
|
umode_t mode,
|
2009-03-26 17:25:38 -06:00
|
|
|
struct dentry *parent,
|
|
|
|
void *data,
|
|
|
|
const struct file_operations *fops);
|
|
|
|
|
2012-05-11 11:29:49 -06:00
|
|
|
struct dentry *tracing_init_dentry_tr(struct trace_array *tr);
|
2008-05-12 13:20:42 -06:00
|
|
|
struct dentry *tracing_init_dentry(void);
|
2008-05-12 13:20:49 -06: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-05 11:14:13 -07:00
|
|
|
struct ring_buffer_event;
|
|
|
|
|
2009-09-02 12:17:06 -06: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-05 11:14:13 -07:00
|
|
|
|
2008-09-16 12:56:41 -06:00
|
|
|
struct trace_entry *tracing_get_trace_entry(struct trace_array *tr,
|
|
|
|
struct trace_array_cpu *data);
|
2009-02-02 15:29:21 -07:00
|
|
|
|
|
|
|
struct trace_entry *trace_find_next_entry(struct trace_iterator *iter,
|
|
|
|
int *ent_cpu, u64 *ent_ts);
|
|
|
|
|
2012-10-11 10:14:25 -06:00
|
|
|
void __buffer_unlock_commit(struct ring_buffer *buffer,
|
|
|
|
struct ring_buffer_event *event);
|
|
|
|
|
2010-08-05 08:22:23 -06: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-12 13:20:42 -06:00
|
|
|
void tracing_sched_switch_trace(struct trace_array *tr,
|
|
|
|
struct task_struct *prev,
|
|
|
|
struct task_struct *next,
|
2008-10-01 11:14:09 -06:00
|
|
|
unsigned long flags, int pc);
|
2008-05-12 13:20:51 -06:00
|
|
|
|
|
|
|
void tracing_sched_wakeup_trace(struct trace_array *tr,
|
|
|
|
struct task_struct *wakee,
|
|
|
|
struct task_struct *cur,
|
2008-10-01 11:14:09 -06:00
|
|
|
unsigned long flags, int pc);
|
2008-05-12 13:20:49 -06:00
|
|
|
void trace_function(struct trace_array *tr,
|
|
|
|
unsigned long ip,
|
|
|
|
unsigned long parent_ip,
|
2008-10-01 11:14:09 -06:00
|
|
|
unsigned long flags, int pc);
|
2010-09-23 06:00:52 -06: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 08:08:49 -07:00
|
|
|
void trace_latency_header(struct seq_file *m);
|
2010-04-02 11:01:22 -06: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-12 13:20:42 -06:00
|
|
|
|
2008-11-25 16:57:25 -07:00
|
|
|
void trace_graph_return(struct ftrace_graph_ret *trace);
|
2008-12-02 21:50:05 -07:00
|
|
|
int trace_graph_entry(struct ftrace_graph_ent *trace);
|
2009-07-29 10:59:58 -06:00
|
|
|
void set_graph_array(struct trace_array *tr);
|
2008-11-25 01:24:15 -07:00
|
|
|
|
2008-05-22 09:49:22 -06:00
|
|
|
void tracing_start_cmdline_record(void);
|
|
|
|
void tracing_stop_cmdline_record(void);
|
2008-11-07 20:36:02 -07:00
|
|
|
void tracing_sched_switch_assign_trace(struct trace_array *tr);
|
|
|
|
void tracing_stop_sched_switch_record(void);
|
|
|
|
void tracing_start_sched_switch_record(void);
|
2008-05-12 13:20:42 -06:00
|
|
|
int register_tracer(struct tracer *type);
|
2009-09-12 17:43:07 -06:00
|
|
|
int is_tracing_stopped(void);
|
2010-08-05 08:22:23 -06:00
|
|
|
|
2013-12-21 15:39:40 -07:00
|
|
|
loff_t tracing_lseek(struct file *file, loff_t offset, int whence);
|
|
|
|
|
2010-08-05 08:22:23 -06: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-12 13:20:42 -06:00
|
|
|
|
|
|
|
extern unsigned long nsecs_to_usecs(unsigned long nsecs);
|
|
|
|
|
2010-02-25 16:36:43 -07:00
|
|
|
extern unsigned long tracing_thresh;
|
|
|
|
|
2009-08-27 14:52:21 -06:00
|
|
|
#ifdef CONFIG_TRACER_MAX_TRACE
|
2008-05-12 13:20:42 -06: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-27 14:52:21 -06:00
|
|
|
#endif /* CONFIG_TRACER_MAX_TRACE */
|
2008-05-12 13:20:42 -06:00
|
|
|
|
2009-07-29 09:51:13 -06:00
|
|
|
#ifdef CONFIG_STACKTRACE
|
2009-09-02 12:17:06 -06:00
|
|
|
void ftrace_trace_stack(struct ring_buffer *buffer, unsigned long flags,
|
2009-07-29 09:51:13 -06:00
|
|
|
int skip, int pc);
|
|
|
|
|
2011-06-08 01:09:34 -06:00
|
|
|
void ftrace_trace_stack_regs(struct ring_buffer *buffer, unsigned long flags,
|
|
|
|
int skip, int pc, struct pt_regs *regs);
|
|
|
|
|
2009-09-02 12:17:06 -06:00
|
|
|
void ftrace_trace_userstack(struct ring_buffer *buffer, unsigned long flags,
|
2009-07-29 09:51:13 -06:00
|
|
|
int pc);
|
|
|
|
|
|
|
|
void __trace_stack(struct trace_array *tr, unsigned long flags, int skip,
|
|
|
|
int pc);
|
|
|
|
#else
|
2010-05-09 21:23:00 -06:00
|
|
|
static inline void ftrace_trace_stack(struct ring_buffer *buffer,
|
2009-07-29 09:51:13 -06:00
|
|
|
unsigned long flags, int skip, int pc)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2011-06-08 01:09:34 -06:00
|
|
|
static inline void ftrace_trace_stack_regs(struct ring_buffer *buffer,
|
|
|
|
unsigned long flags, int skip,
|
|
|
|
int pc, struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2010-05-09 21:23:00 -06:00
|
|
|
static inline void ftrace_trace_userstack(struct ring_buffer *buffer,
|
2009-07-29 09:51:13 -06: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-15 17:12:40 -07:00
|
|
|
|
2008-05-12 13:20:51 -06:00
|
|
|
extern cycle_t ftrace_now(int cpu);
|
2008-05-12 13:20:42 -06:00
|
|
|
|
2009-03-16 17:20:15 -06:00
|
|
|
extern void trace_find_cmdline(int pid, char comm[]);
|
2008-12-29 05:02:17 -07:00
|
|
|
|
2008-05-12 13:20:42 -06:00
|
|
|
#ifdef CONFIG_DYNAMIC_FTRACE
|
|
|
|
extern unsigned long ftrace_update_tot_cnt;
|
2012-07-20 11:45:59 -06:00
|
|
|
#endif
|
2008-05-12 13:20:54 -06:00
|
|
|
#define DYN_FTRACE_TEST_NAME trace_selftest_dynamic_test_func
|
|
|
|
extern int DYN_FTRACE_TEST_NAME(void);
|
2011-05-05 22:08:51 -06:00
|
|
|
#define DYN_FTRACE_TEST_NAME2 trace_selftest_dynamic_test_func2
|
|
|
|
extern int DYN_FTRACE_TEST_NAME2(void);
|
2008-05-12 13:20:42 -06:00
|
|
|
|
2013-03-07 20:48:09 -07:00
|
|
|
extern bool ring_buffer_expanded;
|
2009-06-30 20:47:05 -06:00
|
|
|
extern bool tracing_selftest_disabled;
|
2009-10-07 17:17:45 -06:00
|
|
|
DECLARE_PER_CPU(int, ftrace_cpu_disabled);
|
2009-06-30 20:47:05 -06:00
|
|
|
|
2008-05-12 13:20:44 -06:00
|
|
|
#ifdef CONFIG_FTRACE_STARTUP_TEST
|
|
|
|
extern int trace_selftest_startup_function(struct tracer *trace,
|
|
|
|
struct trace_array *tr);
|
2009-02-07 13:33:57 -07:00
|
|
|
extern int trace_selftest_startup_function_graph(struct tracer *trace,
|
|
|
|
struct trace_array *tr);
|
2008-05-12 13:20:44 -06: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 04:06:43 -06:00
|
|
|
extern int trace_selftest_startup_nop(struct tracer *trace,
|
|
|
|
struct trace_array *tr);
|
2008-05-12 13:20:44 -06:00
|
|
|
extern int trace_selftest_startup_sched_switch(struct tracer *trace,
|
|
|
|
struct trace_array *tr);
|
2008-11-12 13:24:24 -07:00
|
|
|
extern int trace_selftest_startup_branch(struct tracer *trace,
|
|
|
|
struct trace_array *tr);
|
2013-07-18 12:41:51 -06: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-12 13:20:44 -06:00
|
|
|
#endif /* CONFIG_FTRACE_STARTUP_TEST */
|
|
|
|
|
2008-05-12 13:20:45 -06:00
|
|
|
extern void *head_page(struct trace_array_cpu *data);
|
2009-03-29 23:48:00 -06:00
|
|
|
extern unsigned long long ns2usecs(cycle_t nsec);
|
2008-12-03 15:45:11 -07:00
|
|
|
extern int
|
2009-03-19 12:03:53 -06:00
|
|
|
trace_vbprintk(unsigned long ip, const char *fmt, va_list args);
|
2009-03-12 11:24:49 -06:00
|
|
|
extern int
|
2009-03-19 12:03:53 -06:00
|
|
|
trace_vprintk(unsigned long ip, const char *fmt, va_list args);
|
2009-09-03 17:11:07 -06: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 07:24:35 -07:00
|
|
|
int trace_array_printk_buf(struct ring_buffer *buffer,
|
|
|
|
unsigned long ip, const char *fmt, ...);
|
2010-08-05 08:22:23 -06:00
|
|
|
void trace_printk_seq(struct trace_seq *s);
|
|
|
|
enum print_line_t print_trace_line(struct trace_iterator *iter);
|
2008-05-12 13:20:45 -06:00
|
|
|
|
2008-05-12 13:20:52 -06:00
|
|
|
extern unsigned long trace_flags;
|
|
|
|
|
2008-11-10 23:14:25 -07:00
|
|
|
/* Standard output formatting function used for function return traces */
|
2008-11-25 13:07:04 -07:00
|
|
|
#ifdef CONFIG_FUNCTION_GRAPH_TRACER
|
2010-04-02 11:01:22 -06: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-20 16:10:36 -06:00
|
|
|
#define TRACE_GRAPH_PRINT_IRQS 0x40
|
2014-05-20 16:10:51 -06:00
|
|
|
#define TRACE_GRAPH_PRINT_TAIL 0x80
|
2013-11-06 12: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-02 11:01:22 -06:00
|
|
|
|
2010-04-02 11:01:21 -06: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);
|
2009-03-23 21:12:58 -06:00
|
|
|
extern enum print_line_t
|
|
|
|
trace_print_graph_duration(unsigned long long duration, struct trace_seq *s);
|
2010-04-02 11:01:22 -06: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-03 13:36:57 -07:00
|
|
|
|
|
|
|
#ifdef CONFIG_DYNAMIC_FTRACE
|
|
|
|
/* TODO: make this variable */
|
|
|
|
#define FTRACE_GRAPH_MAX_FUNCS 32
|
|
|
|
extern int ftrace_graph_count;
|
|
|
|
extern unsigned long ftrace_graph_funcs[FTRACE_GRAPH_MAX_FUNCS];
|
2013-10-14 02:24:26 -06:00
|
|
|
extern int ftrace_graph_notrace_count;
|
|
|
|
extern unsigned long ftrace_graph_notrace_funcs[FTRACE_GRAPH_MAX_FUNCS];
|
2008-12-03 13:36:57 -07:00
|
|
|
|
|
|
|
static inline int ftrace_graph_addr(unsigned long addr)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2013-10-14 02:24:23 -06:00
|
|
|
if (!ftrace_graph_count)
|
2008-12-03 13:36:57 -07:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
for (i = 0; i < ftrace_graph_count; i++) {
|
2011-06-14 17:02:29 -06:00
|
|
|
if (addr == ftrace_graph_funcs[i]) {
|
|
|
|
/*
|
|
|
|
* 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);
|
2008-12-03 13:36:57 -07:00
|
|
|
return 1;
|
2011-06-14 17:02:29 -06:00
|
|
|
}
|
2008-12-03 13:36:57 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2013-10-14 02:24:26 -06:00
|
|
|
|
|
|
|
static inline int ftrace_graph_notrace_addr(unsigned long addr)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!ftrace_graph_notrace_count)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
for (i = 0; i < ftrace_graph_notrace_count; i++) {
|
|
|
|
if (addr == ftrace_graph_notrace_funcs[i])
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2008-11-10 23:14:25 -07:00
|
|
|
#else
|
2008-12-04 01:18:28 -07:00
|
|
|
static inline int ftrace_graph_addr(unsigned long addr)
|
|
|
|
{
|
|
|
|
return 1;
|
2008-12-03 13:36:57 -07:00
|
|
|
}
|
2013-10-14 02:24:26 -06:00
|
|
|
|
|
|
|
static inline int ftrace_graph_notrace_addr(unsigned long addr)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2008-12-03 13:36:57 -07:00
|
|
|
#endif /* CONFIG_DYNAMIC_FTRACE */
|
|
|
|
#else /* CONFIG_FUNCTION_GRAPH_TRACER */
|
2008-11-10 23:14:25 -07:00
|
|
|
static inline enum print_line_t
|
2010-04-02 11:01:21 -06:00
|
|
|
print_graph_function_flags(struct trace_iterator *iter, u32 flags)
|
2008-11-10 23:14:25 -07:00
|
|
|
{
|
|
|
|
return TRACE_TYPE_UNHANDLED;
|
|
|
|
}
|
2008-12-03 13:36:57 -07:00
|
|
|
#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
|
2008-11-10 23:14:25 -07:00
|
|
|
|
2009-10-13 14:33:52 -06:00
|
|
|
extern struct list_head ftrace_pids;
|
2008-12-03 13:36:59 -07:00
|
|
|
|
2009-06-24 23:30:12 -06:00
|
|
|
#ifdef CONFIG_FUNCTION_TRACER
|
2013-06-27 20:18:06 -06:00
|
|
|
extern bool ftrace_filter_param __initdata;
|
2008-12-03 13:36:59 -07:00
|
|
|
static inline int ftrace_trace_task(struct task_struct *task)
|
|
|
|
{
|
2009-10-13 14:33:52 -06:00
|
|
|
if (list_empty(&ftrace_pids))
|
2008-12-03 13:36:59 -07:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
return test_tsk_trace_trace(task);
|
|
|
|
}
|
2011-09-29 19:26:16 -06:00
|
|
|
extern int ftrace_is_dead(void);
|
2014-01-10 14: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-10 15: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 09:10:43 -06:00
|
|
|
int using_ftrace_ops_list_func(void);
|
2009-06-24 23:30:12 -06:00
|
|
|
#else
|
|
|
|
static inline int ftrace_trace_task(struct task_struct *task)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
2011-09-29 19:26:16 -06:00
|
|
|
static inline int ftrace_is_dead(void) { return 0; }
|
2014-01-10 14: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-10 15: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) { }
|
|
|
|
/* 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-10 14:17:45 -07:00
|
|
|
#endif /* CONFIG_FUNCTION_TRACER */
|
|
|
|
|
|
|
|
#if defined(CONFIG_FUNCTION_TRACER) && defined(CONFIG_DYNAMIC_FTRACE)
|
|
|
|
void ftrace_create_filter_files(struct ftrace_ops *ops,
|
|
|
|
struct dentry *parent);
|
|
|
|
void ftrace_destroy_filter_files(struct ftrace_ops *ops);
|
|
|
|
#else
|
|
|
|
/*
|
|
|
|
* 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-03 13:36:59 -07:00
|
|
|
|
2012-02-15 07:51:52 -07:00
|
|
|
int ftrace_event_is_function(struct ftrace_event_call *call);
|
|
|
|
|
2009-09-11 09:29:27 -06: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 00:57:49 -07:00
|
|
|
* @idx: user input length
|
2009-09-11 09:29:27 -06: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);
|
|
|
|
|
2008-05-12 13:21:00 -06: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
|
|
|
|
* trace.c.
|
|
|
|
*/
|
2008-05-12 13:20:52 -06:00
|
|
|
enum trace_iterator_flags {
|
|
|
|
TRACE_ITER_PRINT_PARENT = 0x01,
|
|
|
|
TRACE_ITER_SYM_OFFSET = 0x02,
|
|
|
|
TRACE_ITER_SYM_ADDR = 0x04,
|
|
|
|
TRACE_ITER_VERBOSE = 0x08,
|
|
|
|
TRACE_ITER_RAW = 0x10,
|
|
|
|
TRACE_ITER_HEX = 0x20,
|
|
|
|
TRACE_ITER_BIN = 0x40,
|
|
|
|
TRACE_ITER_BLOCK = 0x80,
|
|
|
|
TRACE_ITER_STACKTRACE = 0x100,
|
2009-12-07 20:16:26 -07:00
|
|
|
TRACE_ITER_PRINTK = 0x200,
|
|
|
|
TRACE_ITER_PREEMPTONLY = 0x400,
|
|
|
|
TRACE_ITER_BRANCH = 0x800,
|
|
|
|
TRACE_ITER_ANNOTATE = 0x1000,
|
|
|
|
TRACE_ITER_USERSTACKTRACE = 0x2000,
|
|
|
|
TRACE_ITER_SYM_USEROBJ = 0x4000,
|
|
|
|
TRACE_ITER_PRINTK_MSGONLY = 0x8000,
|
|
|
|
TRACE_ITER_CONTEXT_INFO = 0x10000, /* Print pid/cpu/time */
|
|
|
|
TRACE_ITER_LATENCY_FMT = 0x20000,
|
|
|
|
TRACE_ITER_SLEEP_TIME = 0x40000,
|
|
|
|
TRACE_ITER_GRAPH_TIME = 0x80000,
|
2010-07-01 21:07:32 -06:00
|
|
|
TRACE_ITER_RECORD_CMD = 0x100000,
|
2010-12-08 14:46:47 -07:00
|
|
|
TRACE_ITER_OVERWRITE = 0x200000,
|
2011-06-14 20:44:07 -06:00
|
|
|
TRACE_ITER_STOP_ON_FREE = 0x400000,
|
tracing: Add irq, preempt-count and need resched info to default trace output
People keep asking how to get the preempt count, irq, and need resched info
and we keep telling them to enable the latency format. Some developers think
that traces without this info is completely useless, and for a lot of tasks
it is useless.
The first option was to enable the latency trace as the default format, but
the header for the latency format is pretty useless for most tracers and
it also does the timestamp in straight microseconds from the time the trace
started. This is sometimes more difficult to read as the default trace is
seconds from the start of boot up.
Latency format:
# tracer: nop
#
# nop latency trace v1.1.5 on 3.2.0-rc1-test+
# --------------------------------------------------------------------
# latency: 0 us, #159771/64234230, CPU#1 | (M:preempt VP:0, KP:0, SP:0 HP:0 #P:4)
# -----------------
# | task: -0 (uid:0 nice:0 policy:0 rt_prio:0)
# -----------------
#
# _------=> CPU#
# / _-----=> irqs-off
# | / _----=> need-resched
# || / _---=> hardirq/softirq
# ||| / _--=> preempt-depth
# |||| / delay
# cmd pid ||||| time | caller
# \ / ||||| \ | /
migratio-6 0...2 41778231us+: rcu_note_context_switch <-__schedule
migratio-6 0...2 41778233us : trace_rcu_utilization <-rcu_note_context_switch
migratio-6 0...2 41778235us+: rcu_sched_qs <-rcu_note_context_switch
migratio-6 0d..2 41778236us+: rcu_preempt_qs <-rcu_note_context_switch
migratio-6 0...2 41778238us : trace_rcu_utilization <-rcu_note_context_switch
migratio-6 0...2 41778239us+: debug_lockdep_rcu_enabled <-__schedule
default format:
# tracer: nop
#
# TASK-PID CPU# TIMESTAMP FUNCTION
# | | | | |
migration/0-6 [000] 50.025810: rcu_note_context_switch <-__schedule
migration/0-6 [000] 50.025812: trace_rcu_utilization <-rcu_note_context_switch
migration/0-6 [000] 50.025813: rcu_sched_qs <-rcu_note_context_switch
migration/0-6 [000] 50.025815: rcu_preempt_qs <-rcu_note_context_switch
migration/0-6 [000] 50.025817: trace_rcu_utilization <-rcu_note_context_switch
migration/0-6 [000] 50.025818: debug_lockdep_rcu_enabled <-__schedule
migration/0-6 [000] 50.025820: debug_lockdep_rcu_enabled <-__schedule
The latency format header has latency information that is pretty meaningless
for most tracers. Although some of the header is useful, and we can add that
later to the default format as well.
What is really useful with the latency format is the irqs-off, need-resched
hard/softirq context and the preempt count.
This commit adds the option irq-info which is on by default that adds this
information:
# tracer: nop
#
# _-----=> irqs-off
# / _----=> need-resched
# | / _---=> hardirq/softirq
# || / _--=> preempt-depth
# ||| / delay
# TASK-PID CPU# |||| TIMESTAMP FUNCTION
# | | | |||| | |
<idle>-0 [000] d..2 49.309305: cpuidle_get_driver <-cpuidle_idle_call
<idle>-0 [000] d..2 49.309307: mwait_idle <-cpu_idle
<idle>-0 [000] d..2 49.309309: need_resched <-mwait_idle
<idle>-0 [000] d..2 49.309310: test_ti_thread_flag <-need_resched
<idle>-0 [000] d..2 49.309312: trace_power_start.constprop.13 <-mwait_idle
<idle>-0 [000] d..2 49.309313: trace_cpu_idle <-mwait_idle
<idle>-0 [000] d..2 49.309315: need_resched <-mwait_idle
If a user wants the old format, they can disable the 'irq-info' option:
# tracer: nop
#
# TASK-PID CPU# TIMESTAMP FUNCTION
# | | | | |
<idle>-0 [000] 49.309305: cpuidle_get_driver <-cpuidle_idle_call
<idle>-0 [000] 49.309307: mwait_idle <-cpu_idle
<idle>-0 [000] 49.309309: need_resched <-mwait_idle
<idle>-0 [000] 49.309310: test_ti_thread_flag <-need_resched
<idle>-0 [000] 49.309312: trace_power_start.constprop.13 <-mwait_idle
<idle>-0 [000] 49.309313: trace_cpu_idle <-mwait_idle
<idle>-0 [000] 49.309315: need_resched <-mwait_idle
Requested-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2011-11-17 07:34:33 -07:00
|
|
|
TRACE_ITER_IRQ_INFO = 0x800000,
|
2012-09-07 19:12:19 -06:00
|
|
|
TRACE_ITER_MARKERS = 0x1000000,
|
2013-03-14 10:10:40 -06:00
|
|
|
TRACE_ITER_FUNCTION = 0x2000000,
|
2008-05-12 13:20:52 -06:00
|
|
|
};
|
|
|
|
|
2008-11-10 23: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-21 12:16:30 -06:00
|
|
|
extern struct tracer nop_trace;
|
|
|
|
|
2008-11-12 13:24:24 -07:00
|
|
|
#ifdef CONFIG_BRANCH_TRACER
|
2008-11-12 13: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-11 22:14:40 -07:00
|
|
|
{
|
2008-11-12 13:24:24 -07:00
|
|
|
if (trace_flags & TRACE_ITER_BRANCH)
|
|
|
|
return enable_branch_tracing(tr);
|
2008-11-11 22:14:40 -07:00
|
|
|
return 0;
|
|
|
|
}
|
2008-11-12 13:24:24 -07:00
|
|
|
static inline void trace_branch_disable(void)
|
2008-11-11 22:14:40 -07:00
|
|
|
{
|
|
|
|
/* due to races, always disable */
|
2008-11-12 13:24:24 -07:00
|
|
|
disable_branch_tracing();
|
2008-11-11 22:14:40 -07:00
|
|
|
}
|
|
|
|
#else
|
2008-11-12 13:24:24 -07:00
|
|
|
static inline int trace_branch_enable(struct trace_array *tr)
|
2008-11-11 22:14:40 -07:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2008-11-12 13:24:24 -07:00
|
|
|
static inline void trace_branch_disable(void)
|
2008-11-11 22:14:40 -07:00
|
|
|
{
|
|
|
|
}
|
2008-11-12 13:24:24 -07:00
|
|
|
#endif /* CONFIG_BRANCH_TRACER */
|
2008-11-11 22:14:40 -07:00
|
|
|
|
2009-03-11 12:33:00 -06:00
|
|
|
/* set ring buffers to default size if not already done so */
|
|
|
|
int tracing_update_buffers(void);
|
|
|
|
|
2009-03-22 02:30:39 -06:00
|
|
|
struct ftrace_event_field {
|
|
|
|
struct list_head link;
|
2013-02-27 18:41:37 -07:00
|
|
|
const char *name;
|
|
|
|
const char *type;
|
2009-08-06 20:33:02 -06:00
|
|
|
int filter_type;
|
2009-03-22 02:30:39 -06:00
|
|
|
int offset;
|
|
|
|
int size;
|
2009-04-28 02:04:53 -06:00
|
|
|
int is_signed;
|
2009-03-22 02:30:39 -06:00
|
|
|
};
|
|
|
|
|
2009-04-28 02:04:47 -06:00
|
|
|
struct event_filter {
|
2011-01-27 20:42:43 -07:00
|
|
|
int n_preds; /* Number assigned */
|
|
|
|
int a_preds; /* allocated */
|
2011-01-27 20:49:48 -07:00
|
|
|
struct filter_pred *preds;
|
2011-01-27 20: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 02:04:59 -06:00
|
|
|
char *filter_string;
|
2009-04-28 02:04:47 -06:00
|
|
|
};
|
|
|
|
|
2009-03-22 02:31:17 -06:00
|
|
|
struct event_subsystem {
|
|
|
|
struct list_head list;
|
|
|
|
const char *name;
|
2009-07-19 20:20:53 -06:00
|
|
|
struct event_filter *filter;
|
2011-07-05 09:36:06 -06:00
|
|
|
int ref_count;
|
2009-03-22 02:31:17 -06:00
|
|
|
};
|
|
|
|
|
2012-05-03 21:09:03 -06:00
|
|
|
struct ftrace_subsystem_dir {
|
|
|
|
struct list_head list;
|
|
|
|
struct event_subsystem *subsystem;
|
|
|
|
struct trace_array *tr;
|
|
|
|
struct dentry *entry;
|
|
|
|
int ref_count;
|
|
|
|
int nr_events;
|
|
|
|
};
|
|
|
|
|
2011-01-27 20:54:33 -07:00
|
|
|
#define FILTER_PRED_INVALID ((unsigned short)-1)
|
|
|
|
#define FILTER_PRED_IS_RIGHT (1 << 15)
|
2011-01-27 21:16:51 -07:00
|
|
|
#define FILTER_PRED_FOLD (1 << 15)
|
2011-01-27 20:54:33 -07:00
|
|
|
|
2011-01-27 21: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-27 21:19:49 -07:00
|
|
|
|
2009-03-22 02:31:04 -06:00
|
|
|
struct filter_pred;
|
2009-09-24 13:10:44 -06:00
|
|
|
struct regex;
|
2009-03-22 02:31:04 -06:00
|
|
|
|
2011-01-27 20:37:09 -07:00
|
|
|
typedef int (*filter_pred_fn_t) (struct filter_pred *pred, void *event);
|
2009-03-22 02:31:04 -06:00
|
|
|
|
2009-09-24 13:10:44 -06:00
|
|
|
typedef int (*regex_match_func)(char *str, struct regex *r, int len);
|
|
|
|
|
2009-09-24 13:31:51 -06:00
|
|
|
enum regex_type {
|
2009-10-14 21:21:12 -06:00
|
|
|
MATCH_FULL = 0,
|
2009-09-24 13:31:51 -06:00
|
|
|
MATCH_FRONT_ONLY,
|
|
|
|
MATCH_MIDDLE_ONLY,
|
|
|
|
MATCH_END_ONLY,
|
|
|
|
};
|
|
|
|
|
2009-09-24 13:10:44 -06:00
|
|
|
struct regex {
|
|
|
|
char pattern[MAX_FILTER_STR_VAL];
|
|
|
|
int len;
|
|
|
|
int field_len;
|
|
|
|
regex_match_func match;
|
|
|
|
};
|
|
|
|
|
2009-03-22 02:31:04 -06:00
|
|
|
struct filter_pred {
|
2009-09-24 13:10:44 -06:00
|
|
|
filter_pred_fn_t fn;
|
|
|
|
u64 val;
|
|
|
|
struct regex regex;
|
2011-08-11 08:25:47 -06:00
|
|
|
unsigned short *ops;
|
2011-08-11 08:25:54 -06:00
|
|
|
struct ftrace_event_field *field;
|
2009-09-24 13:10:44 -06:00
|
|
|
int offset;
|
|
|
|
int not;
|
|
|
|
int op;
|
2011-01-27 20:54:33 -07:00
|
|
|
unsigned short index;
|
|
|
|
unsigned short parent;
|
|
|
|
unsigned short left;
|
|
|
|
unsigned short right;
|
2009-03-22 02:31:04 -06:00
|
|
|
};
|
|
|
|
|
2009-09-24 13:31:51 -06:00
|
|
|
extern enum regex_type
|
|
|
|
filter_parse_regex(char *buff, int len, char **search, int *not);
|
2013-10-24 07:34:17 -06:00
|
|
|
extern void print_event_filter(struct ftrace_event_file *file,
|
2009-03-24 01:14:31 -06:00
|
|
|
struct trace_seq *s);
|
2013-10-24 07:34:17 -06:00
|
|
|
extern int apply_event_filter(struct ftrace_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 02:04:59 -06:00
|
|
|
char *filter_string);
|
2012-05-03 21:09:03 -06:00
|
|
|
extern int apply_subsystem_event_filter(struct ftrace_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 02:04:59 -06:00
|
|
|
char *filter_string);
|
|
|
|
extern void print_subsystem_event_filter(struct event_subsystem *system,
|
2009-04-16 23:27:08 -06:00
|
|
|
struct trace_seq *s);
|
2009-08-06 20:33:02 -06:00
|
|
|
extern int filter_assign_type(const char *type);
|
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 07:59:29 -06:00
|
|
|
extern int create_event_filter(struct ftrace_event_call *call,
|
|
|
|
char *filter_str, bool set_str,
|
|
|
|
struct event_filter **filterp);
|
|
|
|
extern void free_event_filter(struct event_filter *filter);
|
2009-03-22 02:31:04 -06:00
|
|
|
|
2013-03-11 01:13:42 -06:00
|
|
|
struct ftrace_event_field *
|
|
|
|
trace_find_event_field(struct ftrace_event_call *call, char *name);
|
2010-04-22 08:35:55 -06:00
|
|
|
|
2010-07-01 21:07:32 -06:00
|
|
|
extern void trace_event_enable_cmd_record(bool enable);
|
2012-08-03 14:10:49 -06:00
|
|
|
extern int event_trace_add_tracer(struct dentry *parent, struct trace_array *tr);
|
2012-08-07 14:14:16 -06:00
|
|
|
extern int event_trace_del_tracer(struct trace_array *tr);
|
2010-07-01 21:07:32 -06:00
|
|
|
|
2013-10-24 07:59:28 -06:00
|
|
|
extern struct ftrace_event_file *find_event_file(struct trace_array *tr,
|
|
|
|
const char *system,
|
|
|
|
const char *event);
|
|
|
|
|
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 07:59:24 -06:00
|
|
|
static inline void *event_file_data(struct file *filp)
|
|
|
|
{
|
|
|
|
return ACCESS_ONCE(file_inode(filp)->i_private);
|
|
|
|
}
|
|
|
|
|
2009-05-05 20:33:45 -06:00
|
|
|
extern struct mutex event_mutex;
|
2009-04-10 11:52:20 -06:00
|
|
|
extern struct list_head ftrace_events;
|
2009-03-19 13:26:15 -06: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 07:59:24 -06:00
|
|
|
extern const struct file_operations event_trigger_fops;
|
|
|
|
|
|
|
|
extern int register_trigger_cmds(void);
|
|
|
|
extern void clear_event_triggers(struct trace_array *tr);
|
|
|
|
|
|
|
|
struct event_trigger_data {
|
|
|
|
unsigned long count;
|
|
|
|
int ref;
|
|
|
|
struct event_trigger_ops *ops;
|
|
|
|
struct event_command *cmd_ops;
|
2013-12-21 19: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 07:59:24 -06:00
|
|
|
char *filter_str;
|
|
|
|
void *private_data;
|
|
|
|
struct list_head list;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct event_trigger_ops - callbacks for trace event triggers
|
|
|
|
*
|
|
|
|
* The methods in this structure provide per-event trigger hooks for
|
|
|
|
* various trigger operations.
|
|
|
|
*
|
|
|
|
* All the methods below, except for @init() and @free(), must be
|
|
|
|
* implemented.
|
|
|
|
*
|
|
|
|
* @func: The trigger 'probe' function called when the triggering
|
|
|
|
* event occurs. The data passed into this callback is the data
|
|
|
|
* that was supplied to the event_command @reg() function that
|
|
|
|
* registered the trigger (see struct event_command).
|
|
|
|
*
|
|
|
|
* @init: An optional initialization function called for the trigger
|
|
|
|
* when the trigger is registered (via the event_command reg()
|
|
|
|
* function). This can be used to perform per-trigger
|
|
|
|
* initialization such as incrementing a per-trigger reference
|
|
|
|
* count, for instance. This is usually implemented by the
|
|
|
|
* generic utility function @event_trigger_init() (see
|
|
|
|
* trace_event_triggers.c).
|
|
|
|
*
|
|
|
|
* @free: An optional de-initialization function called for the
|
|
|
|
* trigger when the trigger is unregistered (via the
|
|
|
|
* event_command @reg() function). This can be used to perform
|
|
|
|
* per-trigger de-initialization such as decrementing a
|
|
|
|
* per-trigger reference count and freeing corresponding trigger
|
|
|
|
* data, for instance. This is usually implemented by the
|
|
|
|
* generic utility function @event_trigger_free() (see
|
|
|
|
* trace_event_triggers.c).
|
|
|
|
*
|
|
|
|
* @print: The callback function invoked to have the trigger print
|
|
|
|
* itself. This is usually implemented by a wrapper function
|
|
|
|
* that calls the generic utility function @event_trigger_print()
|
|
|
|
* (see trace_event_triggers.c).
|
|
|
|
*/
|
|
|
|
struct event_trigger_ops {
|
|
|
|
void (*func)(struct event_trigger_data *data);
|
|
|
|
int (*init)(struct event_trigger_ops *ops,
|
|
|
|
struct event_trigger_data *data);
|
|
|
|
void (*free)(struct event_trigger_ops *ops,
|
|
|
|
struct event_trigger_data *data);
|
|
|
|
int (*print)(struct seq_file *m,
|
|
|
|
struct event_trigger_ops *ops,
|
|
|
|
struct event_trigger_data *data);
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct event_command - callbacks and data members for event commands
|
|
|
|
*
|
|
|
|
* Event commands are invoked by users by writing the command name
|
|
|
|
* into the 'trigger' file associated with a trace event. The
|
|
|
|
* parameters associated with a specific invocation of an event
|
|
|
|
* command are used to create an event trigger instance, which is
|
|
|
|
* added to the list of trigger instances associated with that trace
|
|
|
|
* event. When the event is hit, the set of triggers associated with
|
|
|
|
* that event is invoked.
|
|
|
|
*
|
|
|
|
* The data members in this structure provide per-event command data
|
|
|
|
* for various event commands.
|
|
|
|
*
|
|
|
|
* All the data members below, except for @post_trigger, must be set
|
|
|
|
* for each event command.
|
|
|
|
*
|
|
|
|
* @name: The unique name that identifies the event command. This is
|
|
|
|
* the name used when setting triggers via trigger files.
|
|
|
|
*
|
|
|
|
* @trigger_type: A unique id that identifies the event command
|
|
|
|
* 'type'. This value has two purposes, the first to ensure that
|
|
|
|
* only one trigger of the same type can be set at a given time
|
|
|
|
* for a particular event e.g. it doesn't make sense to have both
|
|
|
|
* a traceon and traceoff trigger attached to a single event at
|
|
|
|
* the same time, so traceon and traceoff have the same type
|
|
|
|
* though they have different names. The @trigger_type value is
|
|
|
|
* also used as a bit value for deferring the actual trigger
|
|
|
|
* action until after the current event is finished. Some
|
|
|
|
* commands need to do this if they themselves log to the trace
|
|
|
|
* buffer (see the @post_trigger() member below). @trigger_type
|
|
|
|
* values are defined by adding new values to the trigger_type
|
|
|
|
* enum in include/linux/ftrace_event.h.
|
|
|
|
*
|
|
|
|
* @post_trigger: A flag that says whether or not this command needs
|
|
|
|
* to have its action delayed until after the current event has
|
|
|
|
* been closed. Some triggers need to avoid being invoked while
|
|
|
|
* an event is currently in the process of being logged, since
|
|
|
|
* the trigger may itself log data into the trace buffer. Thus
|
|
|
|
* we make sure the current event is committed before invoking
|
|
|
|
* those triggers. To do that, the trigger invocation is split
|
|
|
|
* in two - the first part checks the filter using the current
|
|
|
|
* trace record; if a command has the @post_trigger flag set, it
|
|
|
|
* sets a bit for itself in the return value, otherwise it
|
|
|
|
* directly invokes the trigger. Once all commands have been
|
|
|
|
* either invoked or set their return flag, the current record is
|
|
|
|
* either committed or discarded. At that point, if any commands
|
|
|
|
* have deferred their triggers, those commands are finally
|
|
|
|
* invoked following the close of the current event. In other
|
|
|
|
* words, if the event_trigger_ops @func() probe implementation
|
|
|
|
* itself logs to the trace buffer, this flag should be set,
|
|
|
|
* otherwise it can be left unspecified.
|
|
|
|
*
|
|
|
|
* All the methods below, except for @set_filter(), must be
|
|
|
|
* implemented.
|
|
|
|
*
|
|
|
|
* @func: The callback function responsible for parsing and
|
|
|
|
* registering the trigger written to the 'trigger' file by the
|
|
|
|
* user. It allocates the trigger instance and registers it with
|
|
|
|
* the appropriate trace event. It makes use of the other
|
|
|
|
* event_command callback functions to orchestrate this, and is
|
|
|
|
* usually implemented by the generic utility function
|
|
|
|
* @event_trigger_callback() (see trace_event_triggers.c).
|
|
|
|
*
|
|
|
|
* @reg: Adds the trigger to the list of triggers associated with the
|
|
|
|
* event, and enables the event trigger itself, after
|
|
|
|
* initializing it (via the event_trigger_ops @init() function).
|
|
|
|
* This is also where commands can use the @trigger_type value to
|
|
|
|
* make the decision as to whether or not multiple instances of
|
|
|
|
* the trigger should be allowed. This is usually implemented by
|
|
|
|
* the generic utility function @register_trigger() (see
|
|
|
|
* trace_event_triggers.c).
|
|
|
|
*
|
|
|
|
* @unreg: Removes the trigger from the list of triggers associated
|
|
|
|
* with the event, and disables the event trigger itself, after
|
|
|
|
* initializing it (via the event_trigger_ops @free() function).
|
|
|
|
* This is usually implemented by the generic utility function
|
|
|
|
* @unregister_trigger() (see trace_event_triggers.c).
|
|
|
|
*
|
|
|
|
* @set_filter: An optional function called to parse and set a filter
|
|
|
|
* for the trigger. If no @set_filter() method is set for the
|
|
|
|
* event command, filters set by the user for the command will be
|
|
|
|
* ignored. This is usually implemented by the generic utility
|
|
|
|
* function @set_trigger_filter() (see trace_event_triggers.c).
|
|
|
|
*
|
|
|
|
* @get_trigger_ops: The callback function invoked to retrieve the
|
|
|
|
* event_trigger_ops implementation associated with the command.
|
|
|
|
*/
|
|
|
|
struct event_command {
|
|
|
|
struct list_head list;
|
|
|
|
char *name;
|
|
|
|
enum event_trigger_type trigger_type;
|
|
|
|
bool post_trigger;
|
|
|
|
int (*func)(struct event_command *cmd_ops,
|
|
|
|
struct ftrace_event_file *file,
|
|
|
|
char *glob, char *cmd, char *params);
|
|
|
|
int (*reg)(char *glob,
|
|
|
|
struct event_trigger_ops *ops,
|
|
|
|
struct event_trigger_data *data,
|
|
|
|
struct ftrace_event_file *file);
|
|
|
|
void (*unreg)(char *glob,
|
|
|
|
struct event_trigger_ops *ops,
|
|
|
|
struct event_trigger_data *data,
|
|
|
|
struct ftrace_event_file *file);
|
|
|
|
int (*set_filter)(char *filter_str,
|
|
|
|
struct event_trigger_data *data,
|
|
|
|
struct ftrace_event_file *file);
|
|
|
|
struct event_trigger_ops *(*get_trigger_ops)(char *cmd, char *param);
|
|
|
|
};
|
|
|
|
|
|
|
|
extern int trace_event_enable_disable(struct ftrace_event_file *file,
|
|
|
|
int enable, int soft_disable);
|
2013-10-24 07:59:26 -06: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 07:59:24 -06:00
|
|
|
|
2009-03-12 12:19:25 -06:00
|
|
|
extern const char *__start___trace_bprintk_fmt[];
|
|
|
|
extern const char *__stop___trace_bprintk_fmt[];
|
|
|
|
|
2013-07-12 15:07:27 -06:00
|
|
|
extern const char *__start___tracepoint_str[];
|
|
|
|
extern const char *__stop___tracepoint_str[];
|
|
|
|
|
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-22 12:01:55 -06:00
|
|
|
void trace_printk_init_buffers(void);
|
2012-10-11 08:15:05 -06:00
|
|
|
void trace_printk_start_comm(void);
|
2013-03-14 13:03:53 -06:00
|
|
|
int trace_keep_overwrite(struct tracer *tracer, u32 mask, int set);
|
2012-05-11 11:29:49 -06: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-22 12:01:55 -06:00
|
|
|
|
2013-03-08 22: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-12 17:26:21 -06:00
|
|
|
#undef FTRACE_ENTRY
|
2012-02-15 07:51:53 -07:00
|
|
|
#define FTRACE_ENTRY(call, struct_name, id, tstruct, print, filter) \
|
2010-02-24 11:59:23 -07:00
|
|
|
extern struct ftrace_event_call \
|
2014-04-07 16:39:20 -06:00
|
|
|
__aligned(4) event_##call;
|
2009-09-12 17:26:21 -06:00
|
|
|
#undef FTRACE_ENTRY_DUP
|
2012-02-15 07: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)
|
2009-09-12 17:26:21 -06:00
|
|
|
#include "trace_entries.h"
|
2009-03-30 23:48:49 -06:00
|
|
|
|
2012-04-13 02:52:59 -06:00
|
|
|
#if defined(CONFIG_PERF_EVENTS) && defined(CONFIG_FUNCTION_TRACER)
|
2012-02-15 07:51:52 -07:00
|
|
|
int perf_ftrace_event_register(struct ftrace_event_call *call,
|
|
|
|
enum trace_reg type, void *data);
|
|
|
|
#else
|
|
|
|
#define perf_ftrace_event_register NULL
|
2012-04-13 02:52:59 -06:00
|
|
|
#endif
|
2012-02-15 07:51:52 -07:00
|
|
|
|
2008-05-12 13:20:42 -06:00
|
|
|
#endif /* _LINUX_KERNEL_TRACE_H */
|