2018-08-16 18:26:55 +03:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
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 17:59:29 +04:00
|
|
|
|
2008-05-12 23:20:42 +04:00
|
|
|
#ifndef _LINUX_KERNEL_TRACE_H
|
|
|
|
#define _LINUX_KERNEL_TRACE_H
|
|
|
|
|
|
|
|
#include <linux/fs.h>
|
2011-07-27 03:09:06 +04:00
|
|
|
#include <linux/atomic.h>
|
2008-05-12 23:20:42 +04:00
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/clocksource.h>
|
2008-09-30 07:02:41 +04: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 23:20:57 +04:00
|
|
|
#include <linux/mmiotrace.h>
|
2009-09-13 03:26:21 +04:00
|
|
|
#include <linux/tracepoint.h>
|
2008-09-23 14:32:08 +04:00
|
|
|
#include <linux/ftrace.h>
|
2019-08-14 20:55:23 +03:00
|
|
|
#include <linux/trace.h>
|
2009-09-09 21:22:48 +04: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 20:59:57 +04:00
|
|
|
#include <linux/trace_seq.h>
|
2015-04-29 21:36:05 +03:00
|
|
|
#include <linux/trace_events.h>
|
2014-04-08 02:39:20 +04:00
|
|
|
#include <linux/compiler.h>
|
2016-10-05 14:58:15 +03:00
|
|
|
#include <linux/glob.h>
|
2019-10-09 01:08:21 +03:00
|
|
|
#include <linux/irq_work.h>
|
|
|
|
#include <linux/workqueue.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 20:59:57 +04:00
|
|
|
|
2012-08-08 22:48:20 +04: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 23:37:28 +04:00
|
|
|
enum trace_type {
|
|
|
|
__TRACE_FIRST_TYPE = 0,
|
|
|
|
|
|
|
|
TRACE_FN,
|
|
|
|
TRACE_CTX,
|
|
|
|
TRACE_WAKE,
|
|
|
|
TRACE_STACK,
|
2008-08-01 20:26:41 +04:00
|
|
|
TRACE_PRINT,
|
2009-03-12 20:24:49 +03: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 23:20:57 +04:00
|
|
|
TRACE_MMIO_RW,
|
|
|
|
TRACE_MMIO_MAP,
|
2008-11-12 23:24:24 +03:00
|
|
|
TRACE_BRANCH,
|
2008-11-26 02:57:25 +03:00
|
|
|
TRACE_GRAPH_RET,
|
|
|
|
TRACE_GRAPH_ENT,
|
2008-11-22 14:28:47 +03: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 17:06:27 +03:00
|
|
|
TRACE_BLK,
|
2013-03-09 06:02:34 +04:00
|
|
|
TRACE_BPUTS,
|
2016-06-23 19:45:36 +03:00
|
|
|
TRACE_HWLAT,
|
2016-07-06 22:25:08 +03:00
|
|
|
TRACE_RAW_DATA,
|
2008-05-23 23:37:28 +04:00
|
|
|
|
2008-12-24 07:24:12 +03:00
|
|
|
__TRACE_LAST_TYPE,
|
2008-05-23 23:37:28 +04:00
|
|
|
};
|
|
|
|
|
2008-05-12 23:20:42 +04:00
|
|
|
|
2009-09-13 03:17:15 +04:00
|
|
|
#undef __field
|
|
|
|
#define __field(type, item) type item;
|
2008-05-12 23:20:51 +04:00
|
|
|
|
2019-10-24 23:26:59 +03:00
|
|
|
#undef __field_fn
|
|
|
|
#define __field_fn(type, item) type item;
|
|
|
|
|
2009-09-13 03:22:23 +04:00
|
|
|
#undef __field_struct
|
|
|
|
#define __field_struct(type, item) __field(type, item)
|
2008-05-12 23:20:51 +04:00
|
|
|
|
2009-09-13 03:22:23 +04:00
|
|
|
#undef __field_desc
|
|
|
|
#define __field_desc(type, container, item)
|
2008-11-22 14:28:47 +03:00
|
|
|
|
2009-09-13 03:17:15 +04:00
|
|
|
#undef __array
|
|
|
|
#define __array(type, item, size) type item[size];
|
2009-03-06 19:21:47 +03:00
|
|
|
|
2009-09-13 03:22:23 +04:00
|
|
|
#undef __array_desc
|
|
|
|
#define __array_desc(type, container, item, size)
|
2008-09-30 07:02:42 +04:00
|
|
|
|
2009-09-13 03:17:15 +04:00
|
|
|
#undef __dynamic_array
|
|
|
|
#define __dynamic_array(type, item) type item[];
|
2008-09-30 07:02:42 +04:00
|
|
|
|
2009-09-13 03:17:15 +04:00
|
|
|
#undef F_STRUCT
|
|
|
|
#define F_STRUCT(args...) args
|
2008-11-12 01:24:42 +03:00
|
|
|
|
2009-09-13 03:17:15 +04:00
|
|
|
#undef FTRACE_ENTRY
|
2019-10-24 23:26:59 +03:00
|
|
|
#define FTRACE_ENTRY(name, struct_name, id, tstruct, print) \
|
2012-02-15 18:51:53 +04:00
|
|
|
struct struct_name { \
|
|
|
|
struct trace_entry ent; \
|
|
|
|
tstruct \
|
2009-09-13 03:17:15 +04:00
|
|
|
}
|
2008-09-30 07:02:42 +04:00
|
|
|
|
2009-09-13 03:17:15 +04:00
|
|
|
#undef FTRACE_ENTRY_DUP
|
2019-10-24 23:26:59 +03:00
|
|
|
#define FTRACE_ENTRY_DUP(name, name_struct, id, tstruct, printk)
|
2008-11-25 11:24:15 +03:00
|
|
|
|
2012-02-15 18:51:51 +04:00
|
|
|
#undef FTRACE_ENTRY_REG
|
2019-10-24 23:26:59 +03:00
|
|
|
#define FTRACE_ENTRY_REG(name, struct_name, id, tstruct, print, regfn) \
|
|
|
|
FTRACE_ENTRY(name, struct_name, id, PARAMS(tstruct), PARAMS(print))
|
2012-02-15 18:51:51 +04:00
|
|
|
|
2016-06-29 13:56:48 +03:00
|
|
|
#undef FTRACE_ENTRY_PACKED
|
2019-10-24 23:26:59 +03:00
|
|
|
#define FTRACE_ENTRY_PACKED(name, struct_name, id, tstruct, print) \
|
|
|
|
FTRACE_ENTRY(name, struct_name, id, PARAMS(tstruct), PARAMS(print)) __packed
|
2016-06-29 13:56:48 +03:00
|
|
|
|
2009-09-13 03:17:15 +04:00
|
|
|
#include "trace_entries.h"
|
2008-12-30 00:42:23 +03:00
|
|
|
|
2020-01-25 18:52:30 +03:00
|
|
|
/* Use this for memory failure errors */
|
|
|
|
#define MEM_FAIL(condition, fmt, ...) ({ \
|
|
|
|
static bool __section(.data.once) __warned; \
|
|
|
|
int __ret_warn_once = !!(condition); \
|
|
|
|
\
|
|
|
|
if (unlikely(__ret_warn_once && !__warned)) { \
|
|
|
|
__warned = true; \
|
|
|
|
pr_err("ERROR: " fmt, ##__VA_ARGS__); \
|
|
|
|
} \
|
|
|
|
unlikely(__ret_warn_once); \
|
|
|
|
})
|
|
|
|
|
2009-09-13 03:17:15 +04:00
|
|
|
/*
|
|
|
|
* syscalls are special, and need special handling, this is why
|
|
|
|
* they are not included in trace_entries.h
|
|
|
|
*/
|
2009-03-13 17:42:11 +03: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 10:14:59 +03:00
|
|
|
long ret;
|
2009-03-13 17:42:11 +03: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 21:17:08 +04:00
|
|
|
struct kprobe_trace_entry_head {
|
2009-08-14 00:35:11 +04: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 21:17:08 +04:00
|
|
|
struct kretprobe_trace_entry_head {
|
2009-08-14 00:35:11 +04:00
|
|
|
struct trace_entry ent;
|
|
|
|
unsigned long func;
|
|
|
|
unsigned long ret_ip;
|
|
|
|
};
|
|
|
|
|
2008-09-16 23:02:27 +04:00
|
|
|
/*
|
|
|
|
* trace_flag_type is an enumeration that holds different
|
|
|
|
* states when a trace occurs. These are:
|
2008-10-24 17:42:59 +04:00
|
|
|
* IRQS_OFF - interrupts were disabled
|
2009-03-06 19:52:03 +03:00
|
|
|
* IRQS_NOSUPPORT - arch does not support irqs_disabled_flags
|
2009-09-10 05:34:19 +04:00
|
|
|
* NEED_RESCHED - reschedule is requested
|
2008-10-24 17:42:59 +04:00
|
|
|
* HARDIRQ - inside an interrupt handler
|
|
|
|
* SOFTIRQ - inside a softirq handler
|
2008-09-16 23:02:27 +04:00
|
|
|
*/
|
|
|
|
enum trace_flag_type {
|
|
|
|
TRACE_FLAG_IRQS_OFF = 0x01,
|
2008-10-24 17:42:59 +04:00
|
|
|
TRACE_FLAG_IRQS_NOSUPPORT = 0x02,
|
|
|
|
TRACE_FLAG_NEED_RESCHED = 0x04,
|
|
|
|
TRACE_FLAG_HARDIRQ = 0x08,
|
|
|
|
TRACE_FLAG_SOFTIRQ = 0x10,
|
2013-10-04 19:28:26 +04:00
|
|
|
TRACE_FLAG_PREEMPT_RESCHED = 0x20,
|
2016-03-18 18:28:04 +03:00
|
|
|
TRACE_FLAG_NMI = 0x40,
|
2008-09-16 23:02:27 +04:00
|
|
|
};
|
|
|
|
|
2008-09-16 23:06:42 +04:00
|
|
|
#define TRACE_BUF_SIZE 1024
|
2008-05-12 23:20:42 +04:00
|
|
|
|
2012-05-11 21:29:49 +04:00
|
|
|
struct trace_array;
|
|
|
|
|
2008-05-12 23:20:42 +04:00
|
|
|
/*
|
|
|
|
* The CPU trace array - it consists of thousands of trace entries
|
|
|
|
* plus some other descriptor data: (for example which task started
|
|
|
|
* the trace, etc.)
|
|
|
|
*/
|
|
|
|
struct trace_array_cpu {
|
|
|
|
atomic_t disabled;
|
2008-12-02 06:20:19 +03:00
|
|
|
void *buffer_page; /* ring buffer spare */
|
2008-05-12 23:20:45 +04:00
|
|
|
|
2012-02-03 00:00:41 +04:00
|
|
|
unsigned long entries;
|
2008-05-12 23:20:42 +04: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 19:06:29 +04:00
|
|
|
unsigned long skipped_entries;
|
2016-12-21 22:32:01 +03:00
|
|
|
u64 preempt_timestamp;
|
2008-05-12 23:20:42 +04:00
|
|
|
pid_t pid;
|
2012-03-14 03:02:19 +04:00
|
|
|
kuid_t uid;
|
2008-05-12 23:20:42 +04:00
|
|
|
char comm[TASK_COMM_LEN];
|
2015-09-25 19:58:44 +03:00
|
|
|
|
2016-04-23 01:11:33 +03:00
|
|
|
#ifdef CONFIG_FUNCTION_TRACER
|
2020-03-20 06:40:40 +03:00
|
|
|
int ftrace_ignore_pid;
|
2016-04-23 01:11:33 +03:00
|
|
|
#endif
|
2020-03-20 06:40:40 +03:00
|
|
|
bool ignore_pid;
|
2008-05-12 23:20:42 +04:00
|
|
|
};
|
|
|
|
|
2012-05-11 21:29:49 +04:00
|
|
|
struct tracer;
|
2015-09-30 21:27:31 +03:00
|
|
|
struct trace_option_dentry;
|
2012-05-11 21:29:49 +04:00
|
|
|
|
2020-01-10 02:53:48 +03:00
|
|
|
struct array_buffer {
|
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 18:24:35 +04:00
|
|
|
struct trace_array *tr;
|
2019-12-13 21:58:57 +03:00
|
|
|
struct trace_buffer *buffer;
|
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 18:24:35 +04:00
|
|
|
struct trace_array_cpu __percpu *data;
|
2016-12-21 22:32:01 +03:00
|
|
|
u64 time_start;
|
tracing: Consolidate max_tr into main trace_array structure
Currently, the way the latency tracers and snapshot feature works
is to have a separate trace_array called "max_tr" that holds the
snapshot buffer. For latency tracers, this snapshot buffer is used
to swap the running buffer with this buffer to save the current max
latency.
The only items needed for the max_tr is really just a copy of the buffer
itself, the per_cpu data pointers, the time_start timestamp that states
when the max latency was triggered, and the cpu that the max latency
was triggered on. All other fields in trace_array are unused by the
max_tr, making the max_tr mostly bloat.
This change removes the max_tr completely, and adds a new structure
called trace_buffer, that holds the buffer pointer, the per_cpu data
pointers, the time_start timestamp, and the cpu where the latency occurred.
The trace_array, now has two trace_buffers, one for the normal trace and
one for the max trace or snapshot. By doing this, not only do we remove
the bloat from the max_trace but the instances of traces can now use
their own snapshot feature and not have just the top level global_trace have
the snapshot feature and latency tracers for itself.
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-03-05 18:24:35 +04:00
|
|
|
int cpu;
|
|
|
|
};
|
|
|
|
|
2015-09-30 18:11:15 +03:00
|
|
|
#define TRACE_FLAGS_MAX_SIZE 32
|
|
|
|
|
2015-09-30 21:27:31 +03:00
|
|
|
struct trace_options {
|
|
|
|
struct tracer *tracer;
|
|
|
|
struct trace_option_dentry *topts;
|
|
|
|
};
|
|
|
|
|
2015-09-24 18:33:26 +03:00
|
|
|
struct trace_pid_list {
|
2016-04-13 23:27:49 +03:00
|
|
|
int pid_max;
|
|
|
|
unsigned long *pids;
|
2015-09-24 18:33:26 +03:00
|
|
|
};
|
|
|
|
|
tracing: Add conditional snapshot
Currently, tracing snapshots are context-free - they capture the ring
buffer contents at the time the tracing_snapshot() function was
invoked, and nothing else. Additionally, they're always taken
unconditionally - the calling code can decide whether or not to take a
snapshot, but the data used to make that decision is kept separately
from the snapshot itself.
This change adds the ability to associate with each trace instance
some user data, along with an 'update' function that can use that data
to determine whether or not to actually take a snapshot. The update
function can then update that data along with any other state (as part
of the data presumably), if warranted.
Because snapshots are 'global' per-instance, only one user can enable
and use a conditional snapshot for any given trace instance. To
enable a conditional snapshot (see details in the function and data
structure comments), the user calls tracing_snapshot_cond_enable().
Similarly, to disable a conditional snapshot and free it up for other
users, tracing_snapshot_cond_disable() should be called.
To actually initiate a conditional snapshot, tracing_snapshot_cond()
should be called. tracing_snapshot_cond() will invoke the update()
callback, allowing the user to decide whether or not to actually take
the snapshot and update the user-defined data associated with the
snapshot. If the callback returns 'true', tracing_snapshot_cond()
will then actually take the snapshot and return.
This scheme allows for flexibility in snapshot implementations - for
example, by implementing slightly different update() callbacks,
snapshots can be taken in situations where the user is only interested
in taking a snapshot when a new maximum in hit versus when a value
changes in any way at all. Future patches will demonstrate both
cases.
Link: http://lkml.kernel.org/r/1bea07828d5fd6864a585f83b1eed47ce097eb45.1550100284.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Signed-off-by: Steven Rostedt (VMware) <rostedt@goodmis.org>
2019-02-14 02:42:45 +03:00
|
|
|
typedef bool (*cond_update_fn_t)(struct trace_array *tr, void *cond_data);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct cond_snapshot - conditional snapshot data and callback
|
|
|
|
*
|
|
|
|
* The cond_snapshot structure encapsulates a callback function and
|
|
|
|
* data associated with the snapshot for a given tracing instance.
|
|
|
|
*
|
|
|
|
* When a snapshot is taken conditionally, by invoking
|
|
|
|
* tracing_snapshot_cond(tr, cond_data), the cond_data passed in is
|
|
|
|
* passed in turn to the cond_snapshot.update() function. That data
|
|
|
|
* can be compared by the update() implementation with the cond_data
|
|
|
|
* contained wihin the struct cond_snapshot instance associated with
|
|
|
|
* the trace_array. Because the tr->max_lock is held throughout the
|
|
|
|
* update() call, the update() function can directly retrieve the
|
|
|
|
* cond_snapshot and cond_data associated with the per-instance
|
|
|
|
* snapshot associated with the trace_array.
|
|
|
|
*
|
|
|
|
* The cond_snapshot.update() implementation can save data to be
|
|
|
|
* associated with the snapshot if it decides to, and returns 'true'
|
|
|
|
* in that case, or it returns 'false' if the conditional snapshot
|
|
|
|
* shouldn't be taken.
|
|
|
|
*
|
|
|
|
* The cond_snapshot instance is created and associated with the
|
|
|
|
* user-defined cond_data by tracing_cond_snapshot_enable().
|
|
|
|
* Likewise, the cond_snapshot instance is destroyed and is no longer
|
|
|
|
* associated with the trace instance by
|
|
|
|
* tracing_cond_snapshot_disable().
|
|
|
|
*
|
|
|
|
* The method below is required.
|
|
|
|
*
|
|
|
|
* @update: When a conditional snapshot is invoked, the update()
|
|
|
|
* callback function is invoked with the tr->max_lock held. The
|
|
|
|
* update() implementation signals whether or not to actually
|
|
|
|
* take the snapshot, by returning 'true' if so, 'false' if no
|
|
|
|
* snapshot should be taken. Because the max_lock is held for
|
|
|
|
* the duration of update(), the implementation is safe to
|
|
|
|
* directly retrieven and save any implementation data it needs
|
|
|
|
* to in association with the snapshot.
|
|
|
|
*/
|
|
|
|
struct cond_snapshot {
|
|
|
|
void *cond_data;
|
|
|
|
cond_update_fn_t update;
|
|
|
|
};
|
|
|
|
|
2008-05-12 23:20:42 +04:00
|
|
|
/*
|
|
|
|
* The trace array - an array of per-CPU trace arrays. This is the
|
|
|
|
* highest level data structure that individual tracers deal with.
|
|
|
|
* They have on/off state as well:
|
|
|
|
*/
|
|
|
|
struct trace_array {
|
2012-05-04 07:09:03 +04:00
|
|
|
struct list_head list;
|
2012-08-04 00:10:49 +04:00
|
|
|
char *name;
|
2020-01-10 02:53:48 +03:00
|
|
|
struct array_buffer array_buffer;
|
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 18:24:35 +04:00
|
|
|
#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.
|
|
|
|
*
|
2020-01-10 02:53:48 +03:00
|
|
|
* The buffers for the max_buffer are set up the same as the array_buffer
|
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 18:24:35 +04:00
|
|
|
* When a snapshot is taken, the buffer of the max_buffer is swapped
|
2020-01-10 02:53:48 +03:00
|
|
|
* with the buffer of the array_buffer and the buffers are reset for
|
|
|
|
* the array_buffer so the tracing can continue.
|
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 18:24:35 +04:00
|
|
|
*/
|
2020-01-10 02:53:48 +03:00
|
|
|
struct array_buffer max_buffer;
|
2013-03-06 03:25:02 +04:00
|
|
|
bool allocated_snapshot;
|
2016-09-07 19:45:09 +03:00
|
|
|
#endif
|
|
|
|
#if defined(CONFIG_TRACER_MAX_TRACE) || defined(CONFIG_HWLAT_TRACER)
|
2014-01-14 20:28:38 +04:00
|
|
|
unsigned long max_latency;
|
2019-10-09 01:08:21 +03:00
|
|
|
#ifdef CONFIG_FSNOTIFY
|
|
|
|
struct dentry *d_max_latency;
|
|
|
|
struct work_struct fsnotify_work;
|
|
|
|
struct irq_work fsnotify_irqwork;
|
|
|
|
#endif
|
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 18:24:35 +04:00
|
|
|
#endif
|
2015-09-24 18:33:26 +03:00
|
|
|
struct trace_pid_list __rcu *filtered_pids;
|
2014-01-14 19:04:59 +04:00
|
|
|
/*
|
|
|
|
* max_lock is used to protect the swapping of buffers
|
|
|
|
* when taking a max snapshot. The buffers themselves are
|
|
|
|
* protected by per_cpu spinlocks. But the action of the swap
|
|
|
|
* needs its own lock.
|
|
|
|
*
|
|
|
|
* This is defined as a arch_spinlock_t in order to help
|
|
|
|
* with performance when lockdep debugging is enabled.
|
|
|
|
*
|
|
|
|
* It is also used in other places outside the update_max_tr
|
|
|
|
* so it needs to be defined outside of the
|
|
|
|
* CONFIG_TRACER_MAX_TRACE.
|
|
|
|
*/
|
|
|
|
arch_spinlock_t max_lock;
|
2012-02-23 00:50:28 +04:00
|
|
|
int buffer_disabled;
|
2012-08-08 22:48:20 +04:00
|
|
|
#ifdef CONFIG_FTRACE_SYSCALLS
|
|
|
|
int sys_refcount_enter;
|
|
|
|
int sys_refcount_exit;
|
2015-05-05 17:09:53 +03:00
|
|
|
struct trace_event_file __rcu *enter_syscall_files[NR_syscalls];
|
|
|
|
struct trace_event_file __rcu *exit_syscall_files[NR_syscalls];
|
2012-08-08 22:48:20 +04:00
|
|
|
#endif
|
2012-05-11 21:29:49 +04:00
|
|
|
int stop_count;
|
|
|
|
int clock_id;
|
2015-09-30 21:27:31 +03:00
|
|
|
int nr_topts;
|
tracing: Only have rmmod clear buffers that its events were active in
Currently, when a module event is enabled, when that module is removed, it
clears all ring buffers. This is to prevent another module from being loaded
and having one of its trace event IDs from reusing a trace event ID of the
removed module. This could cause undesirable effects as the trace event of
the new module would be using its own processing algorithms to process raw
data of another event. To prevent this, when a module is loaded, if any of
its events have been used (signified by the WAS_ENABLED event call flag,
which is never cleared), all ring buffers are cleared, just in case any one
of them contains event data of the removed event.
The problem is, there's no reason to clear all ring buffers if only one (or
less than all of them) uses one of the events. Instead, only clear the ring
buffers that recorded the events of a module that is being removed.
To do this, instead of keeping the WAS_ENABLED flag with the trace event
call, move it to the per instance (per ring buffer) event file descriptor.
The event file descriptor maps each event to a separate ring buffer
instance. Then when the module is removed, only the ring buffers that
activated one of the module's events get cleared. The rest are not touched.
Signed-off-by: Steven Rostedt (VMware) <rostedt@goodmis.org>
2017-09-01 00:03:47 +03:00
|
|
|
bool clear_trace;
|
2018-11-30 05:38:42 +03:00
|
|
|
int buffer_percent;
|
2019-04-02 05:52:21 +03:00
|
|
|
unsigned int n_err_log_entries;
|
2012-05-11 21:29:49 +04:00
|
|
|
struct tracer *current_trace;
|
2015-09-30 16:42:05 +03:00
|
|
|
unsigned int trace_flags;
|
2015-09-30 18:11:15 +03:00
|
|
|
unsigned char trace_flags_index[TRACE_FLAGS_MAX_SIZE];
|
2012-05-04 07:09:03 +04:00
|
|
|
unsigned int flags;
|
2012-05-11 21:29:49 +04:00
|
|
|
raw_spinlock_t start_lock;
|
2019-04-02 05:52:21 +03:00
|
|
|
struct list_head err_log;
|
2012-05-04 07:09:03 +04:00
|
|
|
struct dentry *dir;
|
2012-05-11 21:29:49 +04:00
|
|
|
struct dentry *options;
|
|
|
|
struct dentry *percpu_dir;
|
2012-05-04 07:09:03 +04:00
|
|
|
struct dentry *event_dir;
|
2015-09-30 21:27:31 +03:00
|
|
|
struct trace_options *topts;
|
2012-05-04 07:09:03 +04:00
|
|
|
struct list_head systems;
|
|
|
|
struct list_head events;
|
2018-05-09 21:17:48 +03:00
|
|
|
struct trace_event_file *trace_marker_file;
|
2013-08-08 20:47:45 +04:00
|
|
|
cpumask_var_t tracing_cpumask; /* only trace on set CPUs */
|
2013-03-07 00:27:24 +04:00
|
|
|
int ref;
|
2013-11-08 05:08:58 +04:00
|
|
|
#ifdef CONFIG_FUNCTION_TRACER
|
|
|
|
struct ftrace_ops *ops;
|
2016-04-23 01:11:33 +03:00
|
|
|
struct trace_pid_list __rcu *function_pids;
|
2017-04-05 20:12:55 +03:00
|
|
|
#ifdef CONFIG_DYNAMIC_FTRACE
|
2017-06-23 22:26:26 +03:00
|
|
|
/* All of these are protected by the ftrace_lock */
|
2017-04-05 20:12:55 +03:00
|
|
|
struct list_head func_probes;
|
2017-06-23 22:26:26 +03:00
|
|
|
struct list_head mod_trace;
|
|
|
|
struct list_head mod_notrace;
|
2017-04-05 20:12:55 +03:00
|
|
|
#endif
|
2013-11-08 05:08:58 +04:00
|
|
|
/* function tracing enabled */
|
|
|
|
int function_enabled;
|
|
|
|
#endif
|
2018-01-16 05:51:39 +03:00
|
|
|
int time_stamp_abs_ref;
|
2018-01-16 05:51:56 +03:00
|
|
|
struct list_head hist_vars;
|
tracing: Add conditional snapshot
Currently, tracing snapshots are context-free - they capture the ring
buffer contents at the time the tracing_snapshot() function was
invoked, and nothing else. Additionally, they're always taken
unconditionally - the calling code can decide whether or not to take a
snapshot, but the data used to make that decision is kept separately
from the snapshot itself.
This change adds the ability to associate with each trace instance
some user data, along with an 'update' function that can use that data
to determine whether or not to actually take a snapshot. The update
function can then update that data along with any other state (as part
of the data presumably), if warranted.
Because snapshots are 'global' per-instance, only one user can enable
and use a conditional snapshot for any given trace instance. To
enable a conditional snapshot (see details in the function and data
structure comments), the user calls tracing_snapshot_cond_enable().
Similarly, to disable a conditional snapshot and free it up for other
users, tracing_snapshot_cond_disable() should be called.
To actually initiate a conditional snapshot, tracing_snapshot_cond()
should be called. tracing_snapshot_cond() will invoke the update()
callback, allowing the user to decide whether or not to actually take
the snapshot and update the user-defined data associated with the
snapshot. If the callback returns 'true', tracing_snapshot_cond()
will then actually take the snapshot and return.
This scheme allows for flexibility in snapshot implementations - for
example, by implementing slightly different update() callbacks,
snapshots can be taken in situations where the user is only interested
in taking a snapshot when a new maximum in hit versus when a value
changes in any way at all. Future patches will demonstrate both
cases.
Link: http://lkml.kernel.org/r/1bea07828d5fd6864a585f83b1eed47ce097eb45.1550100284.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Signed-off-by: Steven Rostedt (VMware) <rostedt@goodmis.org>
2019-02-14 02:42:45 +03:00
|
|
|
#ifdef CONFIG_TRACER_SNAPSHOT
|
|
|
|
struct cond_snapshot *cond_snapshot;
|
|
|
|
#endif
|
2008-05-12 23:20:42 +04:00
|
|
|
};
|
|
|
|
|
2012-05-04 07:09:03 +04:00
|
|
|
enum {
|
|
|
|
TRACE_ARRAY_FL_GLOBAL = (1 << 0)
|
|
|
|
};
|
|
|
|
|
|
|
|
extern struct list_head ftrace_trace_arrays;
|
|
|
|
|
2013-07-02 06:37:54 +04:00
|
|
|
extern struct mutex trace_types_lock;
|
|
|
|
|
2013-07-02 23:30:53 +04:00
|
|
|
extern int trace_array_get(struct trace_array *tr);
|
tracing: Add tracing_check_open_get_tr()
Currently, most files in the tracefs directory test if tracing_disabled is
set. If so, it should return -ENODEV. The tracing_disabled is called when
tracing is found to be broken. Originally it was done in case the ring
buffer was found to be corrupted, and we wanted to prevent reading it from
crashing the kernel. But it's also called if a tracing selftest fails on
boot. It's a one way switch. That is, once it is triggered, tracing is
disabled until reboot.
As most tracefs files can also be used by instances in the tracefs
directory, they need to be carefully done. Each instance has a trace_array
associated to it, and when the instance is removed, the trace_array is
freed. But if an instance is opened with a reference to the trace_array,
then it requires looking up the trace_array to get its ref counter (as there
could be a race with it being deleted and the open itself). Once it is
found, a reference is added to prevent the instance from being removed (and
the trace_array associated with it freed).
Combine the two checks (tracing_disabled and trace_array_get()) into a
single helper function. This will also make it easier to add lockdown to
tracefs later.
Link: http://lkml.kernel.org/r/20191011135458.7399da44@gandalf.local.home
Signed-off-by: Steven Rostedt (VMware) <rostedt@goodmis.org>
2019-10-12 00:39:57 +03:00
|
|
|
extern int tracing_check_open_get_tr(struct trace_array *tr);
|
2020-01-29 21:59:21 +03:00
|
|
|
extern struct trace_array *trace_array_find(const char *instance);
|
|
|
|
extern struct trace_array *trace_array_find_get(const char *instance);
|
2013-07-02 23:30:53 +04:00
|
|
|
|
2018-01-16 05:51:39 +03:00
|
|
|
extern int tracing_set_time_stamp_abs(struct trace_array *tr, bool abs);
|
2018-01-16 05:52:07 +03:00
|
|
|
extern int tracing_set_clock(struct trace_array *tr, const char *clockstr);
|
2018-01-16 05:51:39 +03:00
|
|
|
|
2018-01-16 05:51:48 +03:00
|
|
|
extern bool trace_clock_in_ns(struct trace_array *tr);
|
|
|
|
|
2012-05-04 07:09:03 +04: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 21:53:50 +04:00
|
|
|
if (list_empty(&ftrace_trace_arrays))
|
2014-06-06 02:35:17 +04:00
|
|
|
return NULL;
|
|
|
|
|
2012-05-04 07:09:03 +04:00
|
|
|
tr = list_entry(ftrace_trace_arrays.prev,
|
|
|
|
typeof(*tr), list);
|
|
|
|
WARN_ON(!(tr->flags & TRACE_ARRAY_FL_GLOBAL));
|
|
|
|
return tr;
|
|
|
|
}
|
|
|
|
|
2008-10-01 18:52:51 +04:00
|
|
|
#define FTRACE_CMP_TYPE(var, type) \
|
|
|
|
__builtin_types_compatible_p(typeof(var), type *)
|
|
|
|
|
|
|
|
#undef IF_ASSIGN
|
2019-09-26 19:22:59 +03:00
|
|
|
#define IF_ASSIGN(var, entry, etype, id) \
|
|
|
|
if (FTRACE_CMP_TYPE(var, etype)) { \
|
|
|
|
var = (typeof(var))(entry); \
|
|
|
|
WARN_ON(id != 0 && (entry)->type != id); \
|
|
|
|
break; \
|
2008-10-01 18:52:51 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* 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 14:28:47 +03:00
|
|
|
IF_ASSIGN(var, ent, struct userstack_entry, TRACE_USER_STACK);\
|
2008-10-01 18:52:51 +04:00
|
|
|
IF_ASSIGN(var, ent, struct print_entry, TRACE_PRINT); \
|
2009-03-12 20:24:49 +03:00
|
|
|
IF_ASSIGN(var, ent, struct bprint_entry, TRACE_BPRINT); \
|
2013-03-09 06:02:34 +04:00
|
|
|
IF_ASSIGN(var, ent, struct bputs_entry, TRACE_BPUTS); \
|
2016-06-23 19:45:36 +03:00
|
|
|
IF_ASSIGN(var, ent, struct hwlat_entry, TRACE_HWLAT); \
|
2016-07-06 22:25:08 +03:00
|
|
|
IF_ASSIGN(var, ent, struct raw_data_entry, TRACE_RAW_DATA);\
|
2008-10-01 18:52:51 +04: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 23:24:24 +03:00
|
|
|
IF_ASSIGN(var, ent, struct trace_branch, TRACE_BRANCH); \
|
2008-11-26 02:57:25 +03: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 18:52:51 +04:00
|
|
|
__ftrace_bad_type(); \
|
|
|
|
} while (0)
|
2008-09-29 22:18:34 +04:00
|
|
|
|
2008-11-17 21:23:42 +03: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 19:52:03 +03:00
|
|
|
const char *name; /* Will appear on the trace_options file */
|
|
|
|
u32 bit; /* Mask assigned in val field in tracer_flags */
|
2008-11-17 21:23:42 +03: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 19:52:03 +03:00
|
|
|
struct tracer_opt *opts;
|
2016-03-08 16:37:01 +03:00
|
|
|
struct tracer *trace;
|
2008-11-17 21:23:42 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
/* Makes more easy to define a tracer opt */
|
|
|
|
#define TRACER_OPT(s, b) .name = #s, .bit = b
|
|
|
|
|
2009-01-08 21:03:56 +03:00
|
|
|
|
2015-09-30 00:31:55 +03:00
|
|
|
struct trace_option_dentry {
|
|
|
|
struct tracer_opt *opt;
|
|
|
|
struct tracer_flags *flags;
|
|
|
|
struct trace_array *tr;
|
|
|
|
struct dentry *entry;
|
|
|
|
};
|
|
|
|
|
2009-02-11 04:25:00 +03:00
|
|
|
/**
|
2015-01-20 20:13:40 +03:00
|
|
|
* struct tracer - a specific tracer and its callbacks to interact with tracefs
|
2009-02-11 04:25:00 +03:00
|
|
|
* @name: the name chosen to select it on the available_tracers file
|
|
|
|
* @init: called when one switches to this tracer (echo name > current_tracer)
|
|
|
|
* @reset: called when one switches to another tracer
|
2015-12-22 17:44:33 +03:00
|
|
|
* @start: called when tracing is unpaused (echo 1 > tracing_on)
|
|
|
|
* @stop: called when tracing is paused (echo 0 > tracing_on)
|
2014-07-18 15:17:27 +04:00
|
|
|
* @update_thresh: called when tracing_thresh is updated
|
2009-02-11 04:25:00 +03: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 17:06:24 +03:00
|
|
|
* @pipe_close: called when the trace_pipe file is released
|
2009-02-11 04:25:00 +03: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 23:20:42 +04:00
|
|
|
*/
|
|
|
|
struct tracer {
|
|
|
|
const char *name;
|
2008-11-16 07:57:26 +03:00
|
|
|
int (*init)(struct trace_array *tr);
|
2008-05-12 23:20:42 +04:00
|
|
|
void (*reset)(struct trace_array *tr);
|
ftrace: restructure tracing start/stop infrastructure
Impact: change where tracing is started up and stopped
Currently, when a new tracer is selected via echo'ing a tracer name into
the current_tracer file, the startup is only done if tracing_enabled is
set to one. If tracing_enabled is changed to zero (by echo'ing 0 into
the tracing_enabled file) a full shutdown is performed.
The full startup and shutdown of a tracer can be expensive and the
user can lose out traces when echo'ing in 0 to the tracing_enabled file,
because the process takes too long. There can also be places that
the user would like to start and stop the tracer several times and
doing the full startup and shutdown of a tracer might be too expensive.
This patch performs the full startup and shutdown when a tracer is
selected. It also adds a way to do a quick start or stop of a tracer.
The quick version is just a flag that prevents the tracing from
taking place, but the overhead of the code is still there.
For example, the startup of a tracer may enable tracepoints, or enable
the function tracer. The stop and start will just set a flag to
have the tracer ignore the calls when the tracepoint or function trace
is called. The overhead of the tracer may still be present when
the tracer is stopped, but no tracing will occur. Setting the tracer
to the 'nop' tracer (or any other tracer) will perform the shutdown
of the tracer which will disable the tracepoint or disable the
function tracer.
The tracing_enabled file will simply start or stop tracing.
This change is all internal. The end result for the user should be the same
as before. If tracing_enabled is not set, no trace will happen.
If tracing_enabled is set, then the trace will happen. The tracing_enabled
variable is static between tracers. Enabling tracing_enabled and
going to another tracer will keep tracing_enabled enabled. Same
is true with disabling tracing_enabled.
This patch will now provide a fast start/stop method to the users
for enabling or disabling tracing.
Note: There were two methods to the struct tracer that were never
used: The methods start and stop. These were to be used as a hook
to the reading of the trace output, but ended up not being
necessary. These two methods are now used to enable the start
and stop of each tracer, in case the tracer needs to do more than
just not write into the buffer. For example, the irqsoff tracer
must stop recording max latencies when tracing is stopped.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-11-06 00:05:44 +03:00
|
|
|
void (*start)(struct trace_array *tr);
|
|
|
|
void (*stop)(struct trace_array *tr);
|
2014-07-18 15:17:27 +04:00
|
|
|
int (*update_thresh)(struct trace_array *tr);
|
2008-05-12 23:20:42 +04:00
|
|
|
void (*open)(struct trace_iterator *iter);
|
2008-05-12 23:21:01 +04:00
|
|
|
void (*pipe_open)(struct trace_iterator *iter);
|
2008-05-12 23:20:42 +04:00
|
|
|
void (*close)(struct trace_iterator *iter);
|
2009-12-07 17:06:24 +03:00
|
|
|
void (*pipe_close)(struct trace_iterator *iter);
|
2008-05-12 23:21:01 +04:00
|
|
|
ssize_t (*read)(struct trace_iterator *iter,
|
|
|
|
struct file *filp, char __user *ubuf,
|
|
|
|
size_t cnt, loff_t *ppos);
|
2009-02-09 09:15:56 +03: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 23:20:44 +04:00
|
|
|
#ifdef CONFIG_FTRACE_STARTUP_TEST
|
|
|
|
int (*selftest)(struct tracer *trace,
|
|
|
|
struct trace_array *tr);
|
|
|
|
#endif
|
2008-11-25 11:12:31 +03:00
|
|
|
void (*print_header)(struct seq_file *m);
|
2008-09-29 22:18:34 +04:00
|
|
|
enum print_line_t (*print_line)(struct trace_iterator *iter);
|
2008-11-17 21:23:42 +03:00
|
|
|
/* If you handled the flag setting, return 0 */
|
2014-01-10 20:13:54 +04:00
|
|
|
int (*set_flag)(struct trace_array *tr,
|
|
|
|
u32 old_flags, u32 bit, int set);
|
2013-03-14 23:03:53 +04:00
|
|
|
/* Return 0 if OK with change, else return non-zero */
|
2014-01-11 02:51:01 +04:00
|
|
|
int (*flag_changed)(struct trace_array *tr,
|
2013-03-14 23:03:53 +04:00
|
|
|
u32 mask, int set);
|
2008-05-12 23:20:42 +04:00
|
|
|
struct tracer *next;
|
2009-03-06 19:52:03 +03:00
|
|
|
struct tracer_flags *flags;
|
2014-01-14 17:52:35 +04:00
|
|
|
int enabled;
|
2014-12-16 04:13:31 +03:00
|
|
|
int ref;
|
2012-10-02 12:27:10 +04:00
|
|
|
bool print_max;
|
2013-11-07 07:42:48 +04: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 18:24:35 +04:00
|
|
|
#ifdef CONFIG_TRACER_MAX_TRACE
|
2012-10-02 12:27:10 +04: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 18:24:35 +04:00
|
|
|
#endif
|
2017-09-11 09:26:35 +03:00
|
|
|
/* True if tracer cannot be enabled in kernel param */
|
|
|
|
bool noboot;
|
2008-05-12 23:20:42 +04:00
|
|
|
};
|
|
|
|
|
2009-03-02 22:04:40 +03:00
|
|
|
|
2011-06-15 03:02:29 +04:00
|
|
|
/* Only current can touch trace_recursion */
|
|
|
|
|
2012-11-03 01:47:21 +04:00
|
|
|
/*
|
|
|
|
* For function tracing recursion:
|
|
|
|
* The order of these bits are important.
|
|
|
|
*
|
|
|
|
* When function tracing occurs, the following steps are made:
|
|
|
|
* If arch does not support a ftrace feature:
|
|
|
|
* call internal function (uses INTERNAL bits) which calls...
|
|
|
|
* If callback is registered to the "global" list, the list
|
|
|
|
* function is called and recursion checks the GLOBAL bits.
|
|
|
|
* then this function calls...
|
|
|
|
* The function callback, which can use the FTRACE bits to
|
|
|
|
* check for recursion.
|
|
|
|
*
|
|
|
|
* Now if the arch does not suppport a feature, and it calls
|
|
|
|
* the global list function which calls the ftrace callback
|
|
|
|
* all three of these steps will do a recursion protection.
|
|
|
|
* There's no reason to do one if the previous caller already
|
|
|
|
* did. The recursion that we are protecting against will
|
|
|
|
* go through the same steps again.
|
|
|
|
*
|
|
|
|
* To prevent the multiple recursion checks, if a recursion
|
|
|
|
* bit is set that is higher than the MAX bit of the current
|
|
|
|
* check, then we know that the check was made by the previous
|
|
|
|
* caller, and we can skip the current check.
|
|
|
|
*/
|
2012-11-03 01:32:25 +04:00
|
|
|
enum {
|
2020-02-15 00:20:04 +03:00
|
|
|
/* Function recursion bits */
|
2012-11-03 02:33:05 +04:00
|
|
|
TRACE_FTRACE_BIT,
|
2012-11-03 01:47:21 +04:00
|
|
|
TRACE_FTRACE_NMI_BIT,
|
|
|
|
TRACE_FTRACE_IRQ_BIT,
|
|
|
|
TRACE_FTRACE_SIRQ_BIT,
|
2012-11-03 01:32:25 +04:00
|
|
|
|
2014-01-11 02:01:58 +04:00
|
|
|
/* INTERNAL_BITs must be greater than FTRACE_BITs */
|
2012-11-03 01:47:21 +04:00
|
|
|
TRACE_INTERNAL_BIT,
|
|
|
|
TRACE_INTERNAL_NMI_BIT,
|
|
|
|
TRACE_INTERNAL_IRQ_BIT,
|
|
|
|
TRACE_INTERNAL_SIRQ_BIT,
|
|
|
|
|
2015-07-07 22:05:03 +03:00
|
|
|
TRACE_BRANCH_BIT,
|
2011-06-15 03:02:29 +04:00
|
|
|
/*
|
|
|
|
* Abuse of the trace_recursion.
|
|
|
|
* As we need a way to maintain state if we are tracing the function
|
|
|
|
* graph in irq because we want to trace a particular function that
|
|
|
|
* was called in irq context but we have irq tracing off. Since this
|
|
|
|
* can only be modified by current, we can reuse trace_recursion.
|
|
|
|
*/
|
2012-11-03 01:32:25 +04:00
|
|
|
TRACE_IRQ_BIT,
|
tracing/fgraph: Fix set_graph_function from showing interrupts
The tracefs file set_graph_function is used to only function graph functions
that are listed in that file (or all functions if the file is empty). The
way this is implemented is that the function graph tracer looks at every
function, and if the current depth is zero and the function matches
something in the file then it will trace that function. When other functions
are called, the depth will be greater than zero (because the original
function will be at depth zero), and all functions will be traced where the
depth is greater than zero.
The issue is that when a function is first entered, and the handler that
checks this logic is called, the depth is set to zero. If an interrupt comes
in and a function in the interrupt handler is traced, its depth will be
greater than zero and it will automatically be traced, even if the original
function was not. But because the logic only looks at depth it may trace
interrupts when it should not be.
The recent design change of the function graph tracer to fix other bugs
caused the depth to be zero while the function graph callback handler is
being called for a longer time, widening the race of this happening. This
bug was actually there for a longer time, but because the race window was so
small it seldom happened. The Fixes tag below is for the commit that widen
the race window, because that commit belongs to a series that will also help
fix the original bug.
Cc: stable@kernel.org
Fixes: 39eb456dacb5 ("function_graph: Use new curr_ret_depth to manage depth instead of curr_ret_stack")
Reported-by: Joe Lawrence <joe.lawrence@redhat.com>
Tested-by: Joe Lawrence <joe.lawrence@redhat.com>
Signed-off-by: Steven Rostedt (VMware) <rostedt@goodmis.org>
2018-11-29 16:50:27 +03:00
|
|
|
|
|
|
|
/* Set if the function is in the set_graph_function file */
|
|
|
|
TRACE_GRAPH_BIT,
|
|
|
|
|
|
|
|
/*
|
|
|
|
* In the very unlikely case that an interrupt came in
|
|
|
|
* at a start of graph tracing, and we want to trace
|
|
|
|
* the function in that interrupt, the depth can be greater
|
|
|
|
* than zero, because of the preempted start of a previous
|
|
|
|
* trace. In an even more unlikely case, depth could be 2
|
|
|
|
* if a softirq interrupted the start of graph tracing,
|
|
|
|
* followed by an interrupt preempting a start of graph
|
|
|
|
* tracing in the softirq, and depth can even be 3
|
|
|
|
* if an NMI came in at the start of an interrupt function
|
|
|
|
* that preempted a softirq start of a function that
|
|
|
|
* preempted normal context!!!! Luckily, it can't be
|
|
|
|
* greater than 3, so the next two bits are a mask
|
|
|
|
* of what the depth is when we set TRACE_GRAPH_BIT
|
|
|
|
*/
|
|
|
|
|
|
|
|
TRACE_GRAPH_DEPTH_START_BIT,
|
|
|
|
TRACE_GRAPH_DEPTH_END_BIT,
|
2018-11-14 21:14:58 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* To implement set_graph_notrace, if this bit is set, we ignore
|
|
|
|
* function graph tracing of called functions, until the return
|
|
|
|
* function is called to clear it.
|
|
|
|
*/
|
|
|
|
TRACE_GRAPH_NOTRACE_BIT,
|
2012-11-03 01:32:25 +04:00
|
|
|
};
|
2011-06-15 03:02:29 +04:00
|
|
|
|
2012-11-03 01:32:25 +04:00
|
|
|
#define trace_recursion_set(bit) do { (current)->trace_recursion |= (1<<(bit)); } while (0)
|
|
|
|
#define trace_recursion_clear(bit) do { (current)->trace_recursion &= ~(1<<(bit)); } while (0)
|
|
|
|
#define trace_recursion_test(bit) ((current)->trace_recursion & (1<<(bit)))
|
2011-06-15 03:02:29 +04:00
|
|
|
|
tracing/fgraph: Fix set_graph_function from showing interrupts
The tracefs file set_graph_function is used to only function graph functions
that are listed in that file (or all functions if the file is empty). The
way this is implemented is that the function graph tracer looks at every
function, and if the current depth is zero and the function matches
something in the file then it will trace that function. When other functions
are called, the depth will be greater than zero (because the original
function will be at depth zero), and all functions will be traced where the
depth is greater than zero.
The issue is that when a function is first entered, and the handler that
checks this logic is called, the depth is set to zero. If an interrupt comes
in and a function in the interrupt handler is traced, its depth will be
greater than zero and it will automatically be traced, even if the original
function was not. But because the logic only looks at depth it may trace
interrupts when it should not be.
The recent design change of the function graph tracer to fix other bugs
caused the depth to be zero while the function graph callback handler is
being called for a longer time, widening the race of this happening. This
bug was actually there for a longer time, but because the race window was so
small it seldom happened. The Fixes tag below is for the commit that widen
the race window, because that commit belongs to a series that will also help
fix the original bug.
Cc: stable@kernel.org
Fixes: 39eb456dacb5 ("function_graph: Use new curr_ret_depth to manage depth instead of curr_ret_stack")
Reported-by: Joe Lawrence <joe.lawrence@redhat.com>
Tested-by: Joe Lawrence <joe.lawrence@redhat.com>
Signed-off-by: Steven Rostedt (VMware) <rostedt@goodmis.org>
2018-11-29 16:50:27 +03:00
|
|
|
#define trace_recursion_depth() \
|
|
|
|
(((current)->trace_recursion >> TRACE_GRAPH_DEPTH_START_BIT) & 3)
|
|
|
|
#define trace_recursion_set_depth(depth) \
|
|
|
|
do { \
|
|
|
|
current->trace_recursion &= \
|
|
|
|
~(3 << TRACE_GRAPH_DEPTH_START_BIT); \
|
|
|
|
current->trace_recursion |= \
|
|
|
|
((depth) & 3) << TRACE_GRAPH_DEPTH_START_BIT; \
|
|
|
|
} while (0)
|
|
|
|
|
2012-11-03 01:47:21 +04:00
|
|
|
#define TRACE_CONTEXT_BITS 4
|
|
|
|
|
|
|
|
#define TRACE_FTRACE_START TRACE_FTRACE_BIT
|
|
|
|
#define TRACE_FTRACE_MAX ((1 << (TRACE_FTRACE_START + TRACE_CONTEXT_BITS)) - 1)
|
|
|
|
|
|
|
|
#define TRACE_LIST_START TRACE_INTERNAL_BIT
|
|
|
|
#define TRACE_LIST_MAX ((1 << (TRACE_LIST_START + TRACE_CONTEXT_BITS)) - 1)
|
|
|
|
|
|
|
|
#define TRACE_CONTEXT_MASK TRACE_LIST_MAX
|
|
|
|
|
|
|
|
static __always_inline int trace_get_context_bit(void)
|
|
|
|
{
|
|
|
|
int bit;
|
|
|
|
|
|
|
|
if (in_interrupt()) {
|
|
|
|
if (in_nmi())
|
|
|
|
bit = 0;
|
|
|
|
|
|
|
|
else if (in_irq())
|
|
|
|
bit = 1;
|
|
|
|
else
|
|
|
|
bit = 2;
|
|
|
|
} else
|
|
|
|
bit = 3;
|
|
|
|
|
|
|
|
return bit;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __always_inline int trace_test_and_set_recursion(int start, int max)
|
|
|
|
{
|
|
|
|
unsigned int val = current->trace_recursion;
|
|
|
|
int bit;
|
|
|
|
|
|
|
|
/* A previous recursion check was made */
|
|
|
|
if ((val & TRACE_CONTEXT_MASK) > max)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
bit = trace_get_context_bit() + start;
|
|
|
|
if (unlikely(val & (1 << bit)))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
val |= 1 << bit;
|
|
|
|
current->trace_recursion = val;
|
|
|
|
barrier();
|
|
|
|
|
|
|
|
return bit;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __always_inline void trace_clear_recursion(int bit)
|
|
|
|
{
|
|
|
|
unsigned int val = current->trace_recursion;
|
|
|
|
|
|
|
|
if (!bit)
|
|
|
|
return;
|
|
|
|
|
|
|
|
bit = 1 << bit;
|
|
|
|
val &= ~bit;
|
|
|
|
|
|
|
|
barrier();
|
|
|
|
current->trace_recursion = val;
|
|
|
|
}
|
|
|
|
|
2012-06-28 04:46:14 +04:00
|
|
|
static inline struct ring_buffer_iter *
|
|
|
|
trace_buffer_iter(struct trace_iterator *iter, int cpu)
|
|
|
|
{
|
2018-04-08 14:36:31 +03:00
|
|
|
return iter->buffer_iter ? iter->buffer_iter[cpu] : NULL;
|
2012-06-28 04:46:14 +04:00
|
|
|
}
|
|
|
|
|
2009-02-05 23:02:00 +03:00
|
|
|
int tracer_init(struct tracer *t, struct trace_array *tr);
|
ftrace: restructure tracing start/stop infrastructure
Impact: change where tracing is started up and stopped
Currently, when a new tracer is selected via echo'ing a tracer name into
the current_tracer file, the startup is only done if tracing_enabled is
set to one. If tracing_enabled is changed to zero (by echo'ing 0 into
the tracing_enabled file) a full shutdown is performed.
The full startup and shutdown of a tracer can be expensive and the
user can lose out traces when echo'ing in 0 to the tracing_enabled file,
because the process takes too long. There can also be places that
the user would like to start and stop the tracer several times and
doing the full startup and shutdown of a tracer might be too expensive.
This patch performs the full startup and shutdown when a tracer is
selected. It also adds a way to do a quick start or stop of a tracer.
The quick version is just a flag that prevents the tracing from
taking place, but the overhead of the code is still there.
For example, the startup of a tracer may enable tracepoints, or enable
the function tracer. The stop and start will just set a flag to
have the tracer ignore the calls when the tracepoint or function trace
is called. The overhead of the tracer may still be present when
the tracer is stopped, but no tracing will occur. Setting the tracer
to the 'nop' tracer (or any other tracer) will perform the shutdown
of the tracer which will disable the tracepoint or disable the
function tracer.
The tracing_enabled file will simply start or stop tracing.
This change is all internal. The end result for the user should be the same
as before. If tracing_enabled is not set, no trace will happen.
If tracing_enabled is set, then the trace will happen. The tracing_enabled
variable is static between tracers. Enabling tracing_enabled and
going to another tracer will keep tracing_enabled enabled. Same
is true with disabling tracing_enabled.
This patch will now provide a fast start/stop method to the users
for enabling or disabling tracing.
Note: There were two methods to the struct tracer that were never
used: The methods start and stop. These were to be used as a hook
to the reading of the trace output, but ended up not being
necessary. These two methods are now used to enable the start
and stop of each tracer, in case the tracer needs to do more than
just not write into the buffer. For example, the irqsoff tracer
must stop recording max latencies when tracing is stopped.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-11-06 00:05:44 +03:00
|
|
|
int tracing_is_enabled(void);
|
2020-01-10 02:53:48 +03:00
|
|
|
void tracing_reset_online_cpus(struct array_buffer *buf);
|
2009-05-07 05:54:09 +04:00
|
|
|
void tracing_reset_current(int cpu);
|
2013-03-05 08:26:06 +04:00
|
|
|
void tracing_reset_all_online_cpus(void);
|
2008-05-12 23:20:42 +04:00
|
|
|
int tracing_open_generic(struct inode *inode, struct file *filp);
|
2019-10-12 02:12:21 +03:00
|
|
|
int tracing_open_generic_tr(struct inode *inode, struct file *filp);
|
2013-10-19 04:15:54 +04:00
|
|
|
bool tracing_is_disabled(void);
|
2018-08-01 23:08:57 +03:00
|
|
|
bool tracer_tracing_is_on(struct trace_array *tr);
|
2017-04-20 18:46:03 +03:00
|
|
|
void tracer_tracing_on(struct trace_array *tr);
|
|
|
|
void tracer_tracing_off(struct trace_array *tr);
|
2009-03-27 02:25:38 +03:00
|
|
|
struct dentry *trace_create_file(const char *name,
|
2011-07-24 12:33:43 +04:00
|
|
|
umode_t mode,
|
2009-03-27 02:25:38 +03:00
|
|
|
struct dentry *parent,
|
|
|
|
void *data,
|
|
|
|
const struct file_operations *fops);
|
|
|
|
|
2008-05-12 23:20:42 +04:00
|
|
|
struct dentry *tracing_init_dentry(void);
|
2008-05-12 23:20:49 +04: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 21:14:13 +03:00
|
|
|
struct ring_buffer_event;
|
|
|
|
|
2009-09-02 22:17:06 +04:00
|
|
|
struct ring_buffer_event *
|
2019-12-13 21:58:57 +03:00
|
|
|
trace_buffer_lock_reserve(struct trace_buffer *buffer,
|
2009-09-02 22:17:06 +04:00
|
|
|
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 21:14:13 +03:00
|
|
|
|
2008-09-16 22:56:41 +04:00
|
|
|
struct trace_entry *tracing_get_trace_entry(struct trace_array *tr,
|
|
|
|
struct trace_array_cpu *data);
|
2009-02-03 01:29:21 +03:00
|
|
|
|
|
|
|
struct trace_entry *trace_find_next_entry(struct trace_iterator *iter,
|
|
|
|
int *ent_cpu, u64 *ent_ts);
|
|
|
|
|
2019-12-13 21:58:57 +03:00
|
|
|
void trace_buffer_unlock_commit_nostack(struct trace_buffer *buffer,
|
2016-11-24 04:28:38 +03:00
|
|
|
struct ring_buffer_event *event);
|
2012-10-11 20:14:25 +04:00
|
|
|
|
2010-08-05 18:22:23 +04: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);
|
|
|
|
|
2019-03-19 20:12:05 +03:00
|
|
|
unsigned long trace_total_entries_cpu(struct trace_array *tr, int cpu);
|
|
|
|
unsigned long trace_total_entries(struct trace_array *tr);
|
|
|
|
|
2008-05-12 23:20:49 +04:00
|
|
|
void trace_function(struct trace_array *tr,
|
|
|
|
unsigned long ip,
|
|
|
|
unsigned long parent_ip,
|
2008-10-01 21:14:09 +04:00
|
|
|
unsigned long flags, int pc);
|
2010-09-23 16:00:52 +04: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 19:08:49 +04:00
|
|
|
void trace_latency_header(struct seq_file *m);
|
2010-04-02 21:01:22 +04: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 23:20:42 +04:00
|
|
|
|
2008-11-26 02:57:25 +03:00
|
|
|
void trace_graph_return(struct ftrace_graph_ret *trace);
|
2008-12-03 07:50:05 +03:00
|
|
|
int trace_graph_entry(struct ftrace_graph_ent *trace);
|
2009-07-29 20:59:58 +04:00
|
|
|
void set_graph_array(struct trace_array *tr);
|
2008-11-25 11:24:15 +03:00
|
|
|
|
2008-05-22 19:49:22 +04:00
|
|
|
void tracing_start_cmdline_record(void);
|
|
|
|
void tracing_stop_cmdline_record(void);
|
2017-06-27 05:01:55 +03:00
|
|
|
void tracing_start_tgid_record(void);
|
|
|
|
void tracing_stop_tgid_record(void);
|
|
|
|
|
2008-05-12 23:20:42 +04:00
|
|
|
int register_tracer(struct tracer *type);
|
2009-09-13 03:43:07 +04:00
|
|
|
int is_tracing_stopped(void);
|
2010-08-05 18:22:23 +04:00
|
|
|
|
2013-12-22 02:39:40 +04:00
|
|
|
loff_t tracing_lseek(struct file *file, loff_t offset, int whence);
|
|
|
|
|
2010-08-05 18:22:23 +04: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 23:20:42 +04:00
|
|
|
|
|
|
|
extern unsigned long nsecs_to_usecs(unsigned long nsecs);
|
|
|
|
|
2010-02-26 02:36:43 +03:00
|
|
|
extern unsigned long tracing_thresh;
|
|
|
|
|
2016-04-14 14:38:13 +03:00
|
|
|
/* PID filtering */
|
2016-04-21 18:35:30 +03:00
|
|
|
|
|
|
|
extern int pid_max;
|
|
|
|
|
2016-04-14 14:38:13 +03:00
|
|
|
bool trace_find_filtered_pid(struct trace_pid_list *filtered_pids,
|
|
|
|
pid_t search_pid);
|
|
|
|
bool trace_ignore_this_task(struct trace_pid_list *filtered_pids,
|
|
|
|
struct task_struct *task);
|
|
|
|
void trace_filter_add_remove_task(struct trace_pid_list *pid_list,
|
|
|
|
struct task_struct *self,
|
|
|
|
struct task_struct *task);
|
2016-04-20 22:19:54 +03:00
|
|
|
void *trace_pid_next(struct trace_pid_list *pid_list, void *v, loff_t *pos);
|
|
|
|
void *trace_pid_start(struct trace_pid_list *pid_list, loff_t *pos);
|
|
|
|
int trace_pid_show(struct seq_file *m, void *v);
|
2016-04-21 18:35:30 +03:00
|
|
|
void trace_free_pid_list(struct trace_pid_list *pid_list);
|
|
|
|
int trace_pid_write(struct trace_pid_list *filtered_pids,
|
|
|
|
struct trace_pid_list **new_pid_list,
|
|
|
|
const char __user *ubuf, size_t cnt);
|
2016-04-14 14:38:13 +03:00
|
|
|
|
2009-08-28 00:52:21 +04:00
|
|
|
#ifdef CONFIG_TRACER_MAX_TRACE
|
tracing: Add conditional snapshot
Currently, tracing snapshots are context-free - they capture the ring
buffer contents at the time the tracing_snapshot() function was
invoked, and nothing else. Additionally, they're always taken
unconditionally - the calling code can decide whether or not to take a
snapshot, but the data used to make that decision is kept separately
from the snapshot itself.
This change adds the ability to associate with each trace instance
some user data, along with an 'update' function that can use that data
to determine whether or not to actually take a snapshot. The update
function can then update that data along with any other state (as part
of the data presumably), if warranted.
Because snapshots are 'global' per-instance, only one user can enable
and use a conditional snapshot for any given trace instance. To
enable a conditional snapshot (see details in the function and data
structure comments), the user calls tracing_snapshot_cond_enable().
Similarly, to disable a conditional snapshot and free it up for other
users, tracing_snapshot_cond_disable() should be called.
To actually initiate a conditional snapshot, tracing_snapshot_cond()
should be called. tracing_snapshot_cond() will invoke the update()
callback, allowing the user to decide whether or not to actually take
the snapshot and update the user-defined data associated with the
snapshot. If the callback returns 'true', tracing_snapshot_cond()
will then actually take the snapshot and return.
This scheme allows for flexibility in snapshot implementations - for
example, by implementing slightly different update() callbacks,
snapshots can be taken in situations where the user is only interested
in taking a snapshot when a new maximum in hit versus when a value
changes in any way at all. Future patches will demonstrate both
cases.
Link: http://lkml.kernel.org/r/1bea07828d5fd6864a585f83b1eed47ce097eb45.1550100284.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Signed-off-by: Steven Rostedt (VMware) <rostedt@goodmis.org>
2019-02-14 02:42:45 +03:00
|
|
|
void update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu,
|
|
|
|
void *cond_data);
|
2008-05-12 23:20:42 +04:00
|
|
|
void update_max_tr_single(struct trace_array *tr,
|
|
|
|
struct task_struct *tsk, int cpu);
|
2009-08-28 00:52:21 +04:00
|
|
|
#endif /* CONFIG_TRACER_MAX_TRACE */
|
2008-05-12 23:20:42 +04:00
|
|
|
|
2019-10-09 01:08:21 +03:00
|
|
|
#if (defined(CONFIG_TRACER_MAX_TRACE) || defined(CONFIG_HWLAT_TRACER)) && \
|
|
|
|
defined(CONFIG_FSNOTIFY)
|
|
|
|
|
|
|
|
void latency_fsnotify(struct trace_array *tr);
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
2019-11-15 06:43:58 +03:00
|
|
|
static inline void latency_fsnotify(struct trace_array *tr) { }
|
2019-10-09 01:08:21 +03:00
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2009-07-29 19:51:13 +04:00
|
|
|
#ifdef CONFIG_STACKTRACE
|
|
|
|
void __trace_stack(struct trace_array *tr, unsigned long flags, int skip,
|
|
|
|
int pc);
|
|
|
|
#else
|
|
|
|
static inline void __trace_stack(struct trace_array *tr, unsigned long flags,
|
|
|
|
int skip, int pc)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_STACKTRACE */
|
2009-01-16 03:12:40 +03:00
|
|
|
|
2016-12-21 22:32:01 +03:00
|
|
|
extern u64 ftrace_now(int cpu);
|
2008-05-12 23:20:42 +04:00
|
|
|
|
2009-03-17 02:20:15 +03:00
|
|
|
extern void trace_find_cmdline(int pid, char comm[]);
|
2017-06-27 05:01:55 +03:00
|
|
|
extern int trace_find_tgid(int pid);
|
2016-04-13 23:59:18 +03:00
|
|
|
extern void trace_event_follow_fork(struct trace_array *tr, bool enable);
|
2008-12-29 15:02:17 +03:00
|
|
|
|
2008-05-12 23:20:42 +04:00
|
|
|
#ifdef CONFIG_DYNAMIC_FTRACE
|
|
|
|
extern unsigned long ftrace_update_tot_cnt;
|
2019-10-01 21:38:07 +03:00
|
|
|
extern unsigned long ftrace_number_of_pages;
|
|
|
|
extern unsigned long ftrace_number_of_groups;
|
2017-04-05 20:12:55 +03:00
|
|
|
void ftrace_init_trace_array(struct trace_array *tr);
|
|
|
|
#else
|
|
|
|
static inline void ftrace_init_trace_array(struct trace_array *tr) { }
|
2012-07-20 21:45:59 +04:00
|
|
|
#endif
|
2008-05-12 23:20:54 +04:00
|
|
|
#define DYN_FTRACE_TEST_NAME trace_selftest_dynamic_test_func
|
|
|
|
extern int DYN_FTRACE_TEST_NAME(void);
|
2011-05-06 08:08:51 +04:00
|
|
|
#define DYN_FTRACE_TEST_NAME2 trace_selftest_dynamic_test_func2
|
|
|
|
extern int DYN_FTRACE_TEST_NAME2(void);
|
2008-05-12 23:20:42 +04:00
|
|
|
|
2013-03-08 07:48:09 +04:00
|
|
|
extern bool ring_buffer_expanded;
|
2009-07-01 06:47:05 +04:00
|
|
|
extern bool tracing_selftest_disabled;
|
|
|
|
|
2008-05-12 23:20:44 +04:00
|
|
|
#ifdef CONFIG_FTRACE_STARTUP_TEST
|
|
|
|
extern int trace_selftest_startup_function(struct tracer *trace,
|
|
|
|
struct trace_array *tr);
|
2009-02-07 23:33:57 +03:00
|
|
|
extern int trace_selftest_startup_function_graph(struct tracer *trace,
|
|
|
|
struct trace_array *tr);
|
2008-05-12 23:20:44 +04: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 14:06:43 +04:00
|
|
|
extern int trace_selftest_startup_nop(struct tracer *trace,
|
|
|
|
struct trace_array *tr);
|
2008-11-12 23:24:24 +03:00
|
|
|
extern int trace_selftest_startup_branch(struct tracer *trace,
|
|
|
|
struct trace_array *tr);
|
2013-07-18 22:41:51 +04: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 23:20:44 +04:00
|
|
|
#endif /* CONFIG_FTRACE_STARTUP_TEST */
|
|
|
|
|
2008-05-12 23:20:45 +04:00
|
|
|
extern void *head_page(struct trace_array_cpu *data);
|
2016-12-21 22:32:01 +03:00
|
|
|
extern unsigned long long ns2usecs(u64 nsec);
|
2008-12-04 01:45:11 +03:00
|
|
|
extern int
|
2009-03-19 21:03:53 +03:00
|
|
|
trace_vbprintk(unsigned long ip, const char *fmt, va_list args);
|
2009-03-12 20:24:49 +03:00
|
|
|
extern int
|
2009-03-19 21:03:53 +03:00
|
|
|
trace_vprintk(unsigned long ip, const char *fmt, va_list args);
|
2009-09-04 03:11:07 +04:00
|
|
|
extern int
|
|
|
|
trace_array_vprintk(struct trace_array *tr,
|
|
|
|
unsigned long ip, const char *fmt, va_list args);
|
2019-12-13 21:58:57 +03:00
|
|
|
int trace_array_printk_buf(struct trace_buffer *buffer,
|
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 18:24:35 +04:00
|
|
|
unsigned long ip, const char *fmt, ...);
|
2010-08-05 18:22:23 +04:00
|
|
|
void trace_printk_seq(struct trace_seq *s);
|
|
|
|
enum print_line_t print_trace_line(struct trace_iterator *iter);
|
2008-05-12 23:20:45 +04:00
|
|
|
|
2014-11-24 03:34:19 +03:00
|
|
|
extern char trace_find_mark(unsigned long long duration);
|
|
|
|
|
2017-06-23 22:26:26 +03:00
|
|
|
struct ftrace_hash;
|
|
|
|
|
|
|
|
struct ftrace_mod_load {
|
|
|
|
struct list_head list;
|
|
|
|
char *func;
|
|
|
|
char *module;
|
|
|
|
int enable;
|
|
|
|
};
|
|
|
|
|
2017-06-26 18:47:31 +03:00
|
|
|
enum {
|
|
|
|
FTRACE_HASH_FL_MOD = (1 << 0),
|
|
|
|
};
|
|
|
|
|
2017-01-20 05:44:46 +03:00
|
|
|
struct ftrace_hash {
|
|
|
|
unsigned long size_bits;
|
|
|
|
struct hlist_head *buckets;
|
|
|
|
unsigned long count;
|
2017-06-26 18:47:31 +03:00
|
|
|
unsigned long flags;
|
2017-01-20 05:44:46 +03:00
|
|
|
struct rcu_head rcu;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ftrace_func_entry *
|
|
|
|
ftrace_lookup_ip(struct ftrace_hash *hash, unsigned long ip);
|
|
|
|
|
2017-01-23 15:24:45 +03:00
|
|
|
static __always_inline bool ftrace_hash_empty(struct ftrace_hash *hash)
|
2017-01-20 05:44:46 +03:00
|
|
|
{
|
2017-06-26 18:47:31 +03:00
|
|
|
return !hash || !(hash->count || (hash->flags & FTRACE_HASH_FL_MOD));
|
2017-01-20 05:44:46 +03:00
|
|
|
}
|
|
|
|
|
2008-11-11 09:14:25 +03:00
|
|
|
/* Standard output formatting function used for function return traces */
|
2008-11-25 23:07:04 +03:00
|
|
|
#ifdef CONFIG_FUNCTION_GRAPH_TRACER
|
2010-04-02 21:01:22 +04: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
|
2019-01-01 18:46:10 +03:00
|
|
|
#define TRACE_GRAPH_PRINT_REL_TIME 0x40
|
|
|
|
#define TRACE_GRAPH_PRINT_IRQS 0x80
|
|
|
|
#define TRACE_GRAPH_PRINT_TAIL 0x100
|
|
|
|
#define TRACE_GRAPH_SLEEP_TIME 0x200
|
|
|
|
#define TRACE_GRAPH_GRAPH_TIME 0x400
|
2013-11-06 23:50:06 +04:00
|
|
|
#define TRACE_GRAPH_PRINT_FILL_SHIFT 28
|
|
|
|
#define TRACE_GRAPH_PRINT_FILL_MASK (0x3 << TRACE_GRAPH_PRINT_FILL_SHIFT)
|
2010-04-02 21:01:22 +04:00
|
|
|
|
2015-09-30 02:06:50 +03:00
|
|
|
extern void ftrace_graph_sleep_time_control(bool enable);
|
2018-11-23 21:06:07 +03:00
|
|
|
|
|
|
|
#ifdef CONFIG_FUNCTION_PROFILER
|
2015-09-30 02:06:50 +03:00
|
|
|
extern void ftrace_graph_graph_time_control(bool enable);
|
2018-11-23 21:06:07 +03:00
|
|
|
#else
|
|
|
|
static inline void ftrace_graph_graph_time_control(bool enable) { }
|
|
|
|
#endif
|
2015-09-30 02:06:50 +03:00
|
|
|
|
2010-04-02 21:01:21 +04:00
|
|
|
extern enum print_line_t
|
|
|
|
print_graph_function_flags(struct trace_iterator *iter, u32 flags);
|
|
|
|
extern void print_graph_headers_flags(struct seq_file *s, u32 flags);
|
2014-11-12 22:57:38 +03:00
|
|
|
extern void
|
2009-03-24 06:12:58 +03:00
|
|
|
trace_print_graph_duration(unsigned long long duration, struct trace_seq *s);
|
2010-04-02 21:01:22 +04: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 23:36:57 +03:00
|
|
|
#ifdef CONFIG_DYNAMIC_FTRACE
|
2020-02-01 10:27:04 +03:00
|
|
|
extern struct ftrace_hash __rcu *ftrace_graph_hash;
|
2020-02-05 08:57:02 +03:00
|
|
|
extern struct ftrace_hash __rcu *ftrace_graph_notrace_hash;
|
2008-12-03 23:36:57 +03:00
|
|
|
|
tracing/fgraph: Fix set_graph_function from showing interrupts
The tracefs file set_graph_function is used to only function graph functions
that are listed in that file (or all functions if the file is empty). The
way this is implemented is that the function graph tracer looks at every
function, and if the current depth is zero and the function matches
something in the file then it will trace that function. When other functions
are called, the depth will be greater than zero (because the original
function will be at depth zero), and all functions will be traced where the
depth is greater than zero.
The issue is that when a function is first entered, and the handler that
checks this logic is called, the depth is set to zero. If an interrupt comes
in and a function in the interrupt handler is traced, its depth will be
greater than zero and it will automatically be traced, even if the original
function was not. But because the logic only looks at depth it may trace
interrupts when it should not be.
The recent design change of the function graph tracer to fix other bugs
caused the depth to be zero while the function graph callback handler is
being called for a longer time, widening the race of this happening. This
bug was actually there for a longer time, but because the race window was so
small it seldom happened. The Fixes tag below is for the commit that widen
the race window, because that commit belongs to a series that will also help
fix the original bug.
Cc: stable@kernel.org
Fixes: 39eb456dacb5 ("function_graph: Use new curr_ret_depth to manage depth instead of curr_ret_stack")
Reported-by: Joe Lawrence <joe.lawrence@redhat.com>
Tested-by: Joe Lawrence <joe.lawrence@redhat.com>
Signed-off-by: Steven Rostedt (VMware) <rostedt@goodmis.org>
2018-11-29 16:50:27 +03:00
|
|
|
static inline int ftrace_graph_addr(struct ftrace_graph_ent *trace)
|
2008-12-03 23:36:57 +03:00
|
|
|
{
|
tracing/fgraph: Fix set_graph_function from showing interrupts
The tracefs file set_graph_function is used to only function graph functions
that are listed in that file (or all functions if the file is empty). The
way this is implemented is that the function graph tracer looks at every
function, and if the current depth is zero and the function matches
something in the file then it will trace that function. When other functions
are called, the depth will be greater than zero (because the original
function will be at depth zero), and all functions will be traced where the
depth is greater than zero.
The issue is that when a function is first entered, and the handler that
checks this logic is called, the depth is set to zero. If an interrupt comes
in and a function in the interrupt handler is traced, its depth will be
greater than zero and it will automatically be traced, even if the original
function was not. But because the logic only looks at depth it may trace
interrupts when it should not be.
The recent design change of the function graph tracer to fix other bugs
caused the depth to be zero while the function graph callback handler is
being called for a longer time, widening the race of this happening. This
bug was actually there for a longer time, but because the race window was so
small it seldom happened. The Fixes tag below is for the commit that widen
the race window, because that commit belongs to a series that will also help
fix the original bug.
Cc: stable@kernel.org
Fixes: 39eb456dacb5 ("function_graph: Use new curr_ret_depth to manage depth instead of curr_ret_stack")
Reported-by: Joe Lawrence <joe.lawrence@redhat.com>
Tested-by: Joe Lawrence <joe.lawrence@redhat.com>
Signed-off-by: Steven Rostedt (VMware) <rostedt@goodmis.org>
2018-11-29 16:50:27 +03:00
|
|
|
unsigned long addr = trace->func;
|
2017-01-20 05:44:47 +03:00
|
|
|
int ret = 0;
|
2020-02-01 10:27:04 +03:00
|
|
|
struct ftrace_hash *hash;
|
2017-01-20 05:44:47 +03:00
|
|
|
|
|
|
|
preempt_disable_notrace();
|
|
|
|
|
2020-02-05 10:17:57 +03:00
|
|
|
/*
|
|
|
|
* Have to open code "rcu_dereference_sched()" because the
|
|
|
|
* function graph tracer can be called when RCU is not
|
|
|
|
* "watching".
|
2020-02-05 17:20:32 +03:00
|
|
|
* Protected with schedule_on_each_cpu(ftrace_sync)
|
2020-02-05 10:17:57 +03:00
|
|
|
*/
|
2020-02-01 10:27:04 +03:00
|
|
|
hash = rcu_dereference_protected(ftrace_graph_hash, !preemptible());
|
|
|
|
|
|
|
|
if (ftrace_hash_empty(hash)) {
|
2017-01-20 05:44:47 +03:00
|
|
|
ret = 1;
|
|
|
|
goto out;
|
2008-12-03 23:36:57 +03:00
|
|
|
}
|
|
|
|
|
2020-02-01 10:27:04 +03:00
|
|
|
if (ftrace_lookup_ip(hash, addr)) {
|
tracing/fgraph: Fix set_graph_function from showing interrupts
The tracefs file set_graph_function is used to only function graph functions
that are listed in that file (or all functions if the file is empty). The
way this is implemented is that the function graph tracer looks at every
function, and if the current depth is zero and the function matches
something in the file then it will trace that function. When other functions
are called, the depth will be greater than zero (because the original
function will be at depth zero), and all functions will be traced where the
depth is greater than zero.
The issue is that when a function is first entered, and the handler that
checks this logic is called, the depth is set to zero. If an interrupt comes
in and a function in the interrupt handler is traced, its depth will be
greater than zero and it will automatically be traced, even if the original
function was not. But because the logic only looks at depth it may trace
interrupts when it should not be.
The recent design change of the function graph tracer to fix other bugs
caused the depth to be zero while the function graph callback handler is
being called for a longer time, widening the race of this happening. This
bug was actually there for a longer time, but because the race window was so
small it seldom happened. The Fixes tag below is for the commit that widen
the race window, because that commit belongs to a series that will also help
fix the original bug.
Cc: stable@kernel.org
Fixes: 39eb456dacb5 ("function_graph: Use new curr_ret_depth to manage depth instead of curr_ret_stack")
Reported-by: Joe Lawrence <joe.lawrence@redhat.com>
Tested-by: Joe Lawrence <joe.lawrence@redhat.com>
Signed-off-by: Steven Rostedt (VMware) <rostedt@goodmis.org>
2018-11-29 16:50:27 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This needs to be cleared on the return functions
|
|
|
|
* when the depth is zero.
|
|
|
|
*/
|
|
|
|
trace_recursion_set(TRACE_GRAPH_BIT);
|
|
|
|
trace_recursion_set_depth(trace->depth);
|
|
|
|
|
2017-01-20 05:44:47 +03:00
|
|
|
/*
|
|
|
|
* If no irqs are to be traced, but a set_graph_function
|
|
|
|
* is set, and called by an interrupt handler, we still
|
|
|
|
* want to trace it.
|
|
|
|
*/
|
|
|
|
if (in_irq())
|
|
|
|
trace_recursion_set(TRACE_IRQ_BIT);
|
|
|
|
else
|
|
|
|
trace_recursion_clear(TRACE_IRQ_BIT);
|
|
|
|
ret = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
preempt_enable_notrace();
|
|
|
|
return ret;
|
2008-12-03 23:36:57 +03:00
|
|
|
}
|
2013-10-14 12:24:26 +04:00
|
|
|
|
tracing/fgraph: Fix set_graph_function from showing interrupts
The tracefs file set_graph_function is used to only function graph functions
that are listed in that file (or all functions if the file is empty). The
way this is implemented is that the function graph tracer looks at every
function, and if the current depth is zero and the function matches
something in the file then it will trace that function. When other functions
are called, the depth will be greater than zero (because the original
function will be at depth zero), and all functions will be traced where the
depth is greater than zero.
The issue is that when a function is first entered, and the handler that
checks this logic is called, the depth is set to zero. If an interrupt comes
in and a function in the interrupt handler is traced, its depth will be
greater than zero and it will automatically be traced, even if the original
function was not. But because the logic only looks at depth it may trace
interrupts when it should not be.
The recent design change of the function graph tracer to fix other bugs
caused the depth to be zero while the function graph callback handler is
being called for a longer time, widening the race of this happening. This
bug was actually there for a longer time, but because the race window was so
small it seldom happened. The Fixes tag below is for the commit that widen
the race window, because that commit belongs to a series that will also help
fix the original bug.
Cc: stable@kernel.org
Fixes: 39eb456dacb5 ("function_graph: Use new curr_ret_depth to manage depth instead of curr_ret_stack")
Reported-by: Joe Lawrence <joe.lawrence@redhat.com>
Tested-by: Joe Lawrence <joe.lawrence@redhat.com>
Signed-off-by: Steven Rostedt (VMware) <rostedt@goodmis.org>
2018-11-29 16:50:27 +03:00
|
|
|
static inline void ftrace_graph_addr_finish(struct ftrace_graph_ret *trace)
|
|
|
|
{
|
|
|
|
if (trace_recursion_test(TRACE_GRAPH_BIT) &&
|
|
|
|
trace->depth == trace_recursion_depth())
|
|
|
|
trace_recursion_clear(TRACE_GRAPH_BIT);
|
|
|
|
}
|
|
|
|
|
2013-10-14 12:24:26 +04:00
|
|
|
static inline int ftrace_graph_notrace_addr(unsigned long addr)
|
|
|
|
{
|
2017-01-20 05:44:47 +03:00
|
|
|
int ret = 0;
|
2020-02-05 08:57:02 +03:00
|
|
|
struct ftrace_hash *notrace_hash;
|
2013-10-14 12:24:26 +04:00
|
|
|
|
2017-01-20 05:44:47 +03:00
|
|
|
preempt_disable_notrace();
|
2013-10-14 12:24:26 +04:00
|
|
|
|
2020-02-05 10:17:57 +03:00
|
|
|
/*
|
|
|
|
* Have to open code "rcu_dereference_sched()" because the
|
|
|
|
* function graph tracer can be called when RCU is not
|
|
|
|
* "watching".
|
2020-02-05 17:20:32 +03:00
|
|
|
* Protected with schedule_on_each_cpu(ftrace_sync)
|
2020-02-05 10:17:57 +03:00
|
|
|
*/
|
2020-02-05 08:57:02 +03:00
|
|
|
notrace_hash = rcu_dereference_protected(ftrace_graph_notrace_hash,
|
|
|
|
!preemptible());
|
|
|
|
|
|
|
|
if (ftrace_lookup_ip(notrace_hash, addr))
|
2017-01-20 05:44:47 +03:00
|
|
|
ret = 1;
|
2013-10-14 12:24:26 +04:00
|
|
|
|
2017-01-20 05:44:47 +03:00
|
|
|
preempt_enable_notrace();
|
|
|
|
return ret;
|
2013-10-14 12:24:26 +04:00
|
|
|
}
|
2008-11-11 09:14:25 +03:00
|
|
|
#else
|
tracing/fgraph: Fix set_graph_function from showing interrupts
The tracefs file set_graph_function is used to only function graph functions
that are listed in that file (or all functions if the file is empty). The
way this is implemented is that the function graph tracer looks at every
function, and if the current depth is zero and the function matches
something in the file then it will trace that function. When other functions
are called, the depth will be greater than zero (because the original
function will be at depth zero), and all functions will be traced where the
depth is greater than zero.
The issue is that when a function is first entered, and the handler that
checks this logic is called, the depth is set to zero. If an interrupt comes
in and a function in the interrupt handler is traced, its depth will be
greater than zero and it will automatically be traced, even if the original
function was not. But because the logic only looks at depth it may trace
interrupts when it should not be.
The recent design change of the function graph tracer to fix other bugs
caused the depth to be zero while the function graph callback handler is
being called for a longer time, widening the race of this happening. This
bug was actually there for a longer time, but because the race window was so
small it seldom happened. The Fixes tag below is for the commit that widen
the race window, because that commit belongs to a series that will also help
fix the original bug.
Cc: stable@kernel.org
Fixes: 39eb456dacb5 ("function_graph: Use new curr_ret_depth to manage depth instead of curr_ret_stack")
Reported-by: Joe Lawrence <joe.lawrence@redhat.com>
Tested-by: Joe Lawrence <joe.lawrence@redhat.com>
Signed-off-by: Steven Rostedt (VMware) <rostedt@goodmis.org>
2018-11-29 16:50:27 +03:00
|
|
|
static inline int ftrace_graph_addr(struct ftrace_graph_ent *trace)
|
2008-12-04 11:18:28 +03:00
|
|
|
{
|
|
|
|
return 1;
|
2008-12-03 23:36:57 +03:00
|
|
|
}
|
2013-10-14 12:24:26 +04:00
|
|
|
|
|
|
|
static inline int ftrace_graph_notrace_addr(unsigned long addr)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
tracing/fgraph: Fix set_graph_function from showing interrupts
The tracefs file set_graph_function is used to only function graph functions
that are listed in that file (or all functions if the file is empty). The
way this is implemented is that the function graph tracer looks at every
function, and if the current depth is zero and the function matches
something in the file then it will trace that function. When other functions
are called, the depth will be greater than zero (because the original
function will be at depth zero), and all functions will be traced where the
depth is greater than zero.
The issue is that when a function is first entered, and the handler that
checks this logic is called, the depth is set to zero. If an interrupt comes
in and a function in the interrupt handler is traced, its depth will be
greater than zero and it will automatically be traced, even if the original
function was not. But because the logic only looks at depth it may trace
interrupts when it should not be.
The recent design change of the function graph tracer to fix other bugs
caused the depth to be zero while the function graph callback handler is
being called for a longer time, widening the race of this happening. This
bug was actually there for a longer time, but because the race window was so
small it seldom happened. The Fixes tag below is for the commit that widen
the race window, because that commit belongs to a series that will also help
fix the original bug.
Cc: stable@kernel.org
Fixes: 39eb456dacb5 ("function_graph: Use new curr_ret_depth to manage depth instead of curr_ret_stack")
Reported-by: Joe Lawrence <joe.lawrence@redhat.com>
Tested-by: Joe Lawrence <joe.lawrence@redhat.com>
Signed-off-by: Steven Rostedt (VMware) <rostedt@goodmis.org>
2018-11-29 16:50:27 +03:00
|
|
|
static inline void ftrace_graph_addr_finish(struct ftrace_graph_ret *trace)
|
|
|
|
{ }
|
2008-12-03 23:36:57 +03:00
|
|
|
#endif /* CONFIG_DYNAMIC_FTRACE */
|
2016-12-09 03:28:28 +03:00
|
|
|
|
|
|
|
extern unsigned int fgraph_max_depth;
|
|
|
|
|
|
|
|
static inline bool ftrace_graph_ignore_func(struct ftrace_graph_ent *trace)
|
|
|
|
{
|
|
|
|
/* trace it when it is-nested-in or is a function enabled. */
|
tracing/fgraph: Fix set_graph_function from showing interrupts
The tracefs file set_graph_function is used to only function graph functions
that are listed in that file (or all functions if the file is empty). The
way this is implemented is that the function graph tracer looks at every
function, and if the current depth is zero and the function matches
something in the file then it will trace that function. When other functions
are called, the depth will be greater than zero (because the original
function will be at depth zero), and all functions will be traced where the
depth is greater than zero.
The issue is that when a function is first entered, and the handler that
checks this logic is called, the depth is set to zero. If an interrupt comes
in and a function in the interrupt handler is traced, its depth will be
greater than zero and it will automatically be traced, even if the original
function was not. But because the logic only looks at depth it may trace
interrupts when it should not be.
The recent design change of the function graph tracer to fix other bugs
caused the depth to be zero while the function graph callback handler is
being called for a longer time, widening the race of this happening. This
bug was actually there for a longer time, but because the race window was so
small it seldom happened. The Fixes tag below is for the commit that widen
the race window, because that commit belongs to a series that will also help
fix the original bug.
Cc: stable@kernel.org
Fixes: 39eb456dacb5 ("function_graph: Use new curr_ret_depth to manage depth instead of curr_ret_stack")
Reported-by: Joe Lawrence <joe.lawrence@redhat.com>
Tested-by: Joe Lawrence <joe.lawrence@redhat.com>
Signed-off-by: Steven Rostedt (VMware) <rostedt@goodmis.org>
2018-11-29 16:50:27 +03:00
|
|
|
return !(trace_recursion_test(TRACE_GRAPH_BIT) ||
|
|
|
|
ftrace_graph_addr(trace)) ||
|
2016-12-09 03:28:28 +03:00
|
|
|
(trace->depth < 0) ||
|
|
|
|
(fgraph_max_depth && trace->depth >= fgraph_max_depth);
|
|
|
|
}
|
|
|
|
|
2008-12-03 23:36:57 +03:00
|
|
|
#else /* CONFIG_FUNCTION_GRAPH_TRACER */
|
2008-11-11 09:14:25 +03:00
|
|
|
static inline enum print_line_t
|
2010-04-02 21:01:21 +04:00
|
|
|
print_graph_function_flags(struct trace_iterator *iter, u32 flags)
|
2008-11-11 09:14:25 +03:00
|
|
|
{
|
|
|
|
return TRACE_TYPE_UNHANDLED;
|
|
|
|
}
|
2008-12-03 23:36:57 +03:00
|
|
|
#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
|
2008-11-11 09:14:25 +03:00
|
|
|
|
2009-10-14 00:33:52 +04:00
|
|
|
extern struct list_head ftrace_pids;
|
2008-12-03 23:36:59 +03:00
|
|
|
|
2009-06-25 09:30:12 +04:00
|
|
|
#ifdef CONFIG_FUNCTION_TRACER
|
2017-04-01 02:21:41 +03:00
|
|
|
struct ftrace_func_command {
|
|
|
|
struct list_head list;
|
|
|
|
char *name;
|
2017-04-05 20:12:55 +03:00
|
|
|
int (*func)(struct trace_array *tr,
|
|
|
|
struct ftrace_hash *hash,
|
2017-04-01 02:21:41 +03:00
|
|
|
char *func, char *cmd,
|
|
|
|
char *params, int enable);
|
|
|
|
};
|
2013-06-28 06:18:06 +04:00
|
|
|
extern bool ftrace_filter_param __initdata;
|
2016-04-23 01:11:33 +03:00
|
|
|
static inline int ftrace_trace_task(struct trace_array *tr)
|
2008-12-03 23:36:59 +03:00
|
|
|
{
|
2020-01-10 02:53:48 +03:00
|
|
|
return !this_cpu_read(tr->array_buffer.data->ftrace_ignore_pid);
|
2008-12-03 23:36:59 +03:00
|
|
|
}
|
2011-09-30 05:26:16 +04:00
|
|
|
extern int ftrace_is_dead(void);
|
2014-01-11 01:17:45 +04:00
|
|
|
int ftrace_create_function_files(struct trace_array *tr,
|
|
|
|
struct dentry *parent);
|
|
|
|
void ftrace_destroy_function_files(struct trace_array *tr);
|
2014-01-11 02:01:58 +04: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);
|
2016-04-23 01:11:33 +03:00
|
|
|
void ftrace_init_tracefs(struct trace_array *tr, struct dentry *d_tracer);
|
2016-07-05 17:04:34 +03:00
|
|
|
void ftrace_init_tracefs_toplevel(struct trace_array *tr,
|
|
|
|
struct dentry *d_tracer);
|
2017-04-17 05:44:27 +03:00
|
|
|
void ftrace_clear_pids(struct trace_array *tr);
|
2017-03-03 21:48:42 +03:00
|
|
|
int init_function_trace(void);
|
2017-04-17 05:44:28 +03:00
|
|
|
void ftrace_pid_follow_fork(struct trace_array *tr, bool enable);
|
2009-06-25 09:30:12 +04:00
|
|
|
#else
|
2016-04-23 01:11:33 +03:00
|
|
|
static inline int ftrace_trace_task(struct trace_array *tr)
|
2009-06-25 09:30:12 +04:00
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
2011-09-30 05:26:16 +04:00
|
|
|
static inline int ftrace_is_dead(void) { return 0; }
|
2014-01-11 01:17:45 +04:00
|
|
|
static inline int
|
|
|
|
ftrace_create_function_files(struct trace_array *tr,
|
|
|
|
struct dentry *parent)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
static inline void ftrace_destroy_function_files(struct trace_array *tr) { }
|
2014-01-11 02:01:58 +04:00
|
|
|
static inline __init void
|
|
|
|
ftrace_init_global_array_ops(struct trace_array *tr) { }
|
|
|
|
static inline void ftrace_reset_array_ops(struct trace_array *tr) { }
|
2016-04-23 01:11:33 +03:00
|
|
|
static inline void ftrace_init_tracefs(struct trace_array *tr, struct dentry *d) { }
|
2016-07-05 17:04:34 +03:00
|
|
|
static inline void ftrace_init_tracefs_toplevel(struct trace_array *tr, struct dentry *d) { }
|
2017-04-17 05:44:27 +03:00
|
|
|
static inline void ftrace_clear_pids(struct trace_array *tr) { }
|
2017-03-03 21:48:42 +03:00
|
|
|
static inline int init_function_trace(void) { return 0; }
|
2017-04-17 05:44:28 +03:00
|
|
|
static inline void ftrace_pid_follow_fork(struct trace_array *tr, bool enable) { }
|
2014-01-11 02:01:58 +04:00
|
|
|
/* ftace_func_t type is not defined, use macro instead of static inline */
|
|
|
|
#define ftrace_init_array_ops(tr, func) do { } while (0)
|
2014-01-11 01:17:45 +04:00
|
|
|
#endif /* CONFIG_FUNCTION_TRACER */
|
|
|
|
|
|
|
|
#if defined(CONFIG_FUNCTION_TRACER) && defined(CONFIG_DYNAMIC_FTRACE)
|
2017-04-01 02:01:14 +03:00
|
|
|
|
|
|
|
struct ftrace_probe_ops {
|
|
|
|
void (*func)(unsigned long ip,
|
|
|
|
unsigned long parent_ip,
|
2017-04-11 05:30:05 +03:00
|
|
|
struct trace_array *tr,
|
2017-04-04 01:18:47 +03:00
|
|
|
struct ftrace_probe_ops *ops,
|
tracing/ftrace: Add a better way to pass data via the probe functions
With the redesign of the registration and execution of the function probes
(triggers), data can now be passed from the setup of the probe to the probe
callers that are specific to the trace_array it is on. Although, all probes
still only affect the toplevel trace array, this change will allow for
instances to have their own probes separated from other instances and the
top array.
That is, something like the stacktrace probe can be set to trace only in an
instance and not the toplevel trace array. This isn't implement yet, but
this change sets the ground work for the change.
When a probe callback is triggered (someone writes the probe format into
set_ftrace_filter), it calls register_ftrace_function_probe() passing in
init_data that will be used to initialize the probe. Then for every matching
function, register_ftrace_function_probe() will call the probe_ops->init()
function with the init data that was passed to it, as well as an address to
a place holder that is associated with the probe and the instance. The first
occurrence will have a NULL in the pointer. The init() function will then
initialize it. If other probes are added, or more functions are part of the
probe, the place holder will be passed to the init() function with the place
holder data that it was initialized to the last time.
Then this place_holder is passed to each of the other probe_ops functions,
where it can be used in the function callback. When the probe_ops free()
function is called, it can be called either with the rip of the function
that is being removed from the probe, or zero, indicating that there are no
more functions attached to the probe, and the place holder is about to be
freed. This gives the probe_ops a way to free the data it assigned to the
place holder if it was allocade during the first init call.
Signed-off-by: Steven Rostedt (VMware) <rostedt@goodmis.org>
2017-04-20 05:39:44 +03:00
|
|
|
void *data);
|
2017-04-01 02:01:14 +03:00
|
|
|
int (*init)(struct ftrace_probe_ops *ops,
|
2017-04-11 05:30:05 +03:00
|
|
|
struct trace_array *tr,
|
tracing/ftrace: Add a better way to pass data via the probe functions
With the redesign of the registration and execution of the function probes
(triggers), data can now be passed from the setup of the probe to the probe
callers that are specific to the trace_array it is on. Although, all probes
still only affect the toplevel trace array, this change will allow for
instances to have their own probes separated from other instances and the
top array.
That is, something like the stacktrace probe can be set to trace only in an
instance and not the toplevel trace array. This isn't implement yet, but
this change sets the ground work for the change.
When a probe callback is triggered (someone writes the probe format into
set_ftrace_filter), it calls register_ftrace_function_probe() passing in
init_data that will be used to initialize the probe. Then for every matching
function, register_ftrace_function_probe() will call the probe_ops->init()
function with the init data that was passed to it, as well as an address to
a place holder that is associated with the probe and the instance. The first
occurrence will have a NULL in the pointer. The init() function will then
initialize it. If other probes are added, or more functions are part of the
probe, the place holder will be passed to the init() function with the place
holder data that it was initialized to the last time.
Then this place_holder is passed to each of the other probe_ops functions,
where it can be used in the function callback. When the probe_ops free()
function is called, it can be called either with the rip of the function
that is being removed from the probe, or zero, indicating that there are no
more functions attached to the probe, and the place holder is about to be
freed. This gives the probe_ops a way to free the data it assigned to the
place holder if it was allocade during the first init call.
Signed-off-by: Steven Rostedt (VMware) <rostedt@goodmis.org>
2017-04-20 05:39:44 +03:00
|
|
|
unsigned long ip, void *init_data,
|
|
|
|
void **data);
|
2017-04-01 02:01:14 +03:00
|
|
|
void (*free)(struct ftrace_probe_ops *ops,
|
2017-04-11 05:30:05 +03:00
|
|
|
struct trace_array *tr,
|
tracing/ftrace: Add a better way to pass data via the probe functions
With the redesign of the registration and execution of the function probes
(triggers), data can now be passed from the setup of the probe to the probe
callers that are specific to the trace_array it is on. Although, all probes
still only affect the toplevel trace array, this change will allow for
instances to have their own probes separated from other instances and the
top array.
That is, something like the stacktrace probe can be set to trace only in an
instance and not the toplevel trace array. This isn't implement yet, but
this change sets the ground work for the change.
When a probe callback is triggered (someone writes the probe format into
set_ftrace_filter), it calls register_ftrace_function_probe() passing in
init_data that will be used to initialize the probe. Then for every matching
function, register_ftrace_function_probe() will call the probe_ops->init()
function with the init data that was passed to it, as well as an address to
a place holder that is associated with the probe and the instance. The first
occurrence will have a NULL in the pointer. The init() function will then
initialize it. If other probes are added, or more functions are part of the
probe, the place holder will be passed to the init() function with the place
holder data that it was initialized to the last time.
Then this place_holder is passed to each of the other probe_ops functions,
where it can be used in the function callback. When the probe_ops free()
function is called, it can be called either with the rip of the function
that is being removed from the probe, or zero, indicating that there are no
more functions attached to the probe, and the place holder is about to be
freed. This gives the probe_ops a way to free the data it assigned to the
place holder if it was allocade during the first init call.
Signed-off-by: Steven Rostedt (VMware) <rostedt@goodmis.org>
2017-04-20 05:39:44 +03:00
|
|
|
unsigned long ip, void *data);
|
2017-04-01 02:01:14 +03:00
|
|
|
int (*print)(struct seq_file *m,
|
|
|
|
unsigned long ip,
|
|
|
|
struct ftrace_probe_ops *ops,
|
|
|
|
void *data);
|
|
|
|
};
|
|
|
|
|
2017-04-04 03:58:35 +03:00
|
|
|
struct ftrace_func_mapper;
|
|
|
|
typedef int (*ftrace_mapper_func)(void *data);
|
|
|
|
|
|
|
|
struct ftrace_func_mapper *allocate_ftrace_func_mapper(void);
|
|
|
|
void **ftrace_func_mapper_find_ip(struct ftrace_func_mapper *mapper,
|
|
|
|
unsigned long ip);
|
|
|
|
int ftrace_func_mapper_add_ip(struct ftrace_func_mapper *mapper,
|
|
|
|
unsigned long ip, void *data);
|
|
|
|
void *ftrace_func_mapper_remove_ip(struct ftrace_func_mapper *mapper,
|
|
|
|
unsigned long ip);
|
|
|
|
void free_ftrace_func_mapper(struct ftrace_func_mapper *mapper,
|
|
|
|
ftrace_mapper_func free_func);
|
|
|
|
|
2017-04-01 02:01:14 +03:00
|
|
|
extern int
|
2017-04-05 20:12:55 +03:00
|
|
|
register_ftrace_function_probe(char *glob, struct trace_array *tr,
|
|
|
|
struct ftrace_probe_ops *ops, void *data);
|
2017-04-04 23:44:43 +03:00
|
|
|
extern int
|
2017-04-18 21:50:39 +03:00
|
|
|
unregister_ftrace_function_probe_func(char *glob, struct trace_array *tr,
|
|
|
|
struct ftrace_probe_ops *ops);
|
2017-05-16 20:51:26 +03:00
|
|
|
extern void clear_ftrace_function_probes(struct trace_array *tr);
|
2017-04-01 02:01:14 +03:00
|
|
|
|
2017-04-01 02:21:41 +03:00
|
|
|
int register_ftrace_command(struct ftrace_func_command *cmd);
|
|
|
|
int unregister_ftrace_command(struct ftrace_func_command *cmd);
|
|
|
|
|
2014-01-11 01:17:45 +04:00
|
|
|
void ftrace_create_filter_files(struct ftrace_ops *ops,
|
|
|
|
struct dentry *parent);
|
|
|
|
void ftrace_destroy_filter_files(struct ftrace_ops *ops);
|
2020-01-29 12:36:44 +03:00
|
|
|
|
|
|
|
extern int ftrace_set_filter(struct ftrace_ops *ops, unsigned char *buf,
|
|
|
|
int len, int reset);
|
|
|
|
extern int ftrace_set_notrace(struct ftrace_ops *ops, unsigned char *buf,
|
|
|
|
int len, int reset);
|
2014-01-11 01:17:45 +04:00
|
|
|
#else
|
2017-04-01 02:21:41 +03:00
|
|
|
struct ftrace_func_command;
|
|
|
|
|
|
|
|
static inline __init int register_ftrace_command(struct ftrace_func_command *cmd)
|
|
|
|
{
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
static inline __init int unregister_ftrace_command(char *cmd_name)
|
|
|
|
{
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2017-05-18 04:53:32 +03:00
|
|
|
static inline void clear_ftrace_function_probes(struct trace_array *tr)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2014-01-11 01:17:45 +04:00
|
|
|
/*
|
|
|
|
* The ops parameter passed in is usually undefined.
|
|
|
|
* This must be a macro.
|
|
|
|
*/
|
|
|
|
#define ftrace_create_filter_files(ops, parent) do { } while (0)
|
|
|
|
#define ftrace_destroy_filter_files(ops) do { } while (0)
|
|
|
|
#endif /* CONFIG_FUNCTION_TRACER && CONFIG_DYNAMIC_FTRACE */
|
2008-12-03 23:36:59 +03:00
|
|
|
|
2015-09-29 17:43:36 +03:00
|
|
|
bool ftrace_event_is_function(struct trace_event_call *call);
|
2012-02-15 18:51:52 +04:00
|
|
|
|
2009-09-11 19:29:27 +04: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 10:57:49 +03:00
|
|
|
* @idx: user input length
|
2009-09-11 19:29:27 +04:00
|
|
|
* @size: buffer size
|
|
|
|
*/
|
|
|
|
struct trace_parser {
|
|
|
|
bool cont;
|
|
|
|
char *buffer;
|
|
|
|
unsigned idx;
|
|
|
|
unsigned size;
|
|
|
|
};
|
|
|
|
|
|
|
|
static inline bool trace_parser_loaded(struct trace_parser *parser)
|
|
|
|
{
|
|
|
|
return (parser->idx != 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool trace_parser_cont(struct trace_parser *parser)
|
|
|
|
{
|
|
|
|
return parser->cont;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void trace_parser_clear(struct trace_parser *parser)
|
|
|
|
{
|
|
|
|
parser->cont = false;
|
|
|
|
parser->idx = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
extern int trace_parser_get_init(struct trace_parser *parser, int size);
|
|
|
|
extern void trace_parser_put(struct trace_parser *parser);
|
|
|
|
extern int trace_get_user(struct trace_parser *parser, const char __user *ubuf,
|
|
|
|
size_t cnt, loff_t *ppos);
|
|
|
|
|
2015-09-29 17:15:10 +03:00
|
|
|
/*
|
|
|
|
* Only create function graph options if function graph is configured.
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_FUNCTION_GRAPH_TRACER
|
|
|
|
# define FGRAPH_FLAGS \
|
|
|
|
C(DISPLAY_GRAPH, "display-graph"),
|
|
|
|
#else
|
|
|
|
# define FGRAPH_FLAGS
|
|
|
|
#endif
|
|
|
|
|
2015-09-29 17:19:35 +03:00
|
|
|
#ifdef CONFIG_BRANCH_TRACER
|
|
|
|
# define BRANCH_FLAGS \
|
|
|
|
C(BRANCH, "branch"),
|
|
|
|
#else
|
|
|
|
# define BRANCH_FLAGS
|
|
|
|
#endif
|
|
|
|
|
2015-09-29 17:24:56 +03:00
|
|
|
#ifdef CONFIG_FUNCTION_TRACER
|
|
|
|
# define FUNCTION_FLAGS \
|
2017-04-17 05:44:28 +03:00
|
|
|
C(FUNCTION, "function-trace"), \
|
|
|
|
C(FUNC_FORK, "function-fork"),
|
2015-09-29 17:24:56 +03:00
|
|
|
# define FUNCTION_DEFAULT_FLAGS TRACE_ITER_FUNCTION
|
|
|
|
#else
|
|
|
|
# define FUNCTION_FLAGS
|
|
|
|
# define FUNCTION_DEFAULT_FLAGS 0UL
|
2017-04-17 05:44:28 +03:00
|
|
|
# define TRACE_ITER_FUNC_FORK 0UL
|
2015-09-29 17:24:56 +03:00
|
|
|
#endif
|
|
|
|
|
2015-09-29 22:38:55 +03:00
|
|
|
#ifdef CONFIG_STACKTRACE
|
|
|
|
# define STACK_FLAGS \
|
|
|
|
C(STACKTRACE, "stacktrace"),
|
|
|
|
#else
|
|
|
|
# define STACK_FLAGS
|
|
|
|
#endif
|
|
|
|
|
2008-05-12 23:21:00 +04:00
|
|
|
/*
|
|
|
|
* trace_iterator_flags is an enumeration that defines bit
|
|
|
|
* positions into trace_flags that controls the output.
|
|
|
|
*
|
|
|
|
* NOTE: These bits must match the trace_options array in
|
tracing: Use TRACE_FLAGS macro to keep enums and strings matched
Use a cute little macro trick to keep the names of the trace flags file
guaranteed to match the corresponding masks.
The macro TRACE_FLAGS is defined as a serious of enum names followed by
the string name of the file that matches it. For example:
#define TRACE_FLAGS \
C(PRINT_PARENT, "print-parent"), \
C(SYM_OFFSET, "sym-offset"), \
C(SYM_ADDR, "sym-addr"), \
C(VERBOSE, "verbose"),
Now we can define the following:
#undef C
#define C(a, b) TRACE_ITER_##a##_BIT
enum trace_iterator_bits { TRACE_FLAGS };
The above creates:
enum trace_iterator_bits {
TRACE_ITER_PRINT_PARENT_BIT,
TRACE_ITER_SYM_OFFSET_BIT,
TRACE_ITER_SYM_ADDR_BIT,
TRACE_ITER_VERBOSE_BIT,
};
Then we can redefine C as:
#undef C
#define C(a, b) TRACE_ITER_##a = (1 << TRACE_ITER_##a##_BIT)
enum trace_iterator_flags { TRACE_FLAGS };
Which creates:
enum trace_iterator_flags {
TRACE_ITER_PRINT_PARENT = (1 << TRACE_ITER_PRINT_PARENT_BIT),
TRACE_ITER_SYM_OFFSET = (1 << TRACE_ITER_SYM_OFFSET_BIT),
TRACE_ITER_SYM_ADDR = (1 << TRACE_ITER_SYM_ADDR_BIT),
TRACE_ITER_VERBOSE = (1 << TRACE_ITER_VERBOSE_BIT),
};
Then finally we can create the list of file names:
#undef C
#define C(a, b) b
static const char *trace_options[] = {
TRACE_FLAGS
NULL
};
Which creates:
static const char *trace_options[] = {
"print-parent",
"sym-offset",
"sym-addr",
"verbose",
NULL
};
The importance of this is that the strings match the bit index.
trace_options[TRACE_ITER_SYM_ADDR_BIT] == "sym-addr"
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2015-09-29 16:43:30 +03:00
|
|
|
* trace.c (this macro guarantees it).
|
2008-05-12 23:21:00 +04:00
|
|
|
*/
|
tracing: Use TRACE_FLAGS macro to keep enums and strings matched
Use a cute little macro trick to keep the names of the trace flags file
guaranteed to match the corresponding masks.
The macro TRACE_FLAGS is defined as a serious of enum names followed by
the string name of the file that matches it. For example:
#define TRACE_FLAGS \
C(PRINT_PARENT, "print-parent"), \
C(SYM_OFFSET, "sym-offset"), \
C(SYM_ADDR, "sym-addr"), \
C(VERBOSE, "verbose"),
Now we can define the following:
#undef C
#define C(a, b) TRACE_ITER_##a##_BIT
enum trace_iterator_bits { TRACE_FLAGS };
The above creates:
enum trace_iterator_bits {
TRACE_ITER_PRINT_PARENT_BIT,
TRACE_ITER_SYM_OFFSET_BIT,
TRACE_ITER_SYM_ADDR_BIT,
TRACE_ITER_VERBOSE_BIT,
};
Then we can redefine C as:
#undef C
#define C(a, b) TRACE_ITER_##a = (1 << TRACE_ITER_##a##_BIT)
enum trace_iterator_flags { TRACE_FLAGS };
Which creates:
enum trace_iterator_flags {
TRACE_ITER_PRINT_PARENT = (1 << TRACE_ITER_PRINT_PARENT_BIT),
TRACE_ITER_SYM_OFFSET = (1 << TRACE_ITER_SYM_OFFSET_BIT),
TRACE_ITER_SYM_ADDR = (1 << TRACE_ITER_SYM_ADDR_BIT),
TRACE_ITER_VERBOSE = (1 << TRACE_ITER_VERBOSE_BIT),
};
Then finally we can create the list of file names:
#undef C
#define C(a, b) b
static const char *trace_options[] = {
TRACE_FLAGS
NULL
};
Which creates:
static const char *trace_options[] = {
"print-parent",
"sym-offset",
"sym-addr",
"verbose",
NULL
};
The importance of this is that the strings match the bit index.
trace_options[TRACE_ITER_SYM_ADDR_BIT] == "sym-addr"
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2015-09-29 16:43:30 +03:00
|
|
|
#define TRACE_FLAGS \
|
|
|
|
C(PRINT_PARENT, "print-parent"), \
|
|
|
|
C(SYM_OFFSET, "sym-offset"), \
|
|
|
|
C(SYM_ADDR, "sym-addr"), \
|
|
|
|
C(VERBOSE, "verbose"), \
|
|
|
|
C(RAW, "raw"), \
|
|
|
|
C(HEX, "hex"), \
|
|
|
|
C(BIN, "bin"), \
|
|
|
|
C(BLOCK, "block"), \
|
|
|
|
C(PRINTK, "trace_printk"), \
|
|
|
|
C(ANNOTATE, "annotate"), \
|
|
|
|
C(USERSTACKTRACE, "userstacktrace"), \
|
|
|
|
C(SYM_USEROBJ, "sym-userobj"), \
|
|
|
|
C(PRINTK_MSGONLY, "printk-msg-only"), \
|
|
|
|
C(CONTEXT_INFO, "context-info"), /* Print pid/cpu/time */ \
|
|
|
|
C(LATENCY_FMT, "latency-format"), \
|
|
|
|
C(RECORD_CMD, "record-cmd"), \
|
2017-06-27 05:01:55 +03:00
|
|
|
C(RECORD_TGID, "record-tgid"), \
|
tracing: Use TRACE_FLAGS macro to keep enums and strings matched
Use a cute little macro trick to keep the names of the trace flags file
guaranteed to match the corresponding masks.
The macro TRACE_FLAGS is defined as a serious of enum names followed by
the string name of the file that matches it. For example:
#define TRACE_FLAGS \
C(PRINT_PARENT, "print-parent"), \
C(SYM_OFFSET, "sym-offset"), \
C(SYM_ADDR, "sym-addr"), \
C(VERBOSE, "verbose"),
Now we can define the following:
#undef C
#define C(a, b) TRACE_ITER_##a##_BIT
enum trace_iterator_bits { TRACE_FLAGS };
The above creates:
enum trace_iterator_bits {
TRACE_ITER_PRINT_PARENT_BIT,
TRACE_ITER_SYM_OFFSET_BIT,
TRACE_ITER_SYM_ADDR_BIT,
TRACE_ITER_VERBOSE_BIT,
};
Then we can redefine C as:
#undef C
#define C(a, b) TRACE_ITER_##a = (1 << TRACE_ITER_##a##_BIT)
enum trace_iterator_flags { TRACE_FLAGS };
Which creates:
enum trace_iterator_flags {
TRACE_ITER_PRINT_PARENT = (1 << TRACE_ITER_PRINT_PARENT_BIT),
TRACE_ITER_SYM_OFFSET = (1 << TRACE_ITER_SYM_OFFSET_BIT),
TRACE_ITER_SYM_ADDR = (1 << TRACE_ITER_SYM_ADDR_BIT),
TRACE_ITER_VERBOSE = (1 << TRACE_ITER_VERBOSE_BIT),
};
Then finally we can create the list of file names:
#undef C
#define C(a, b) b
static const char *trace_options[] = {
TRACE_FLAGS
NULL
};
Which creates:
static const char *trace_options[] = {
"print-parent",
"sym-offset",
"sym-addr",
"verbose",
NULL
};
The importance of this is that the strings match the bit index.
trace_options[TRACE_ITER_SYM_ADDR_BIT] == "sym-addr"
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2015-09-29 16:43:30 +03:00
|
|
|
C(OVERWRITE, "overwrite"), \
|
|
|
|
C(STOP_ON_FREE, "disable_on_free"), \
|
|
|
|
C(IRQ_INFO, "irq-info"), \
|
|
|
|
C(MARKERS, "markers"), \
|
2016-04-13 23:59:18 +03:00
|
|
|
C(EVENT_FORK, "event-fork"), \
|
2020-03-18 00:32:31 +03:00
|
|
|
C(PAUSE_ON_TRACE, "pause-on-trace"), \
|
2015-09-29 17:24:56 +03:00
|
|
|
FUNCTION_FLAGS \
|
2015-09-29 17:19:35 +03:00
|
|
|
FGRAPH_FLAGS \
|
2015-09-29 22:38:55 +03:00
|
|
|
STACK_FLAGS \
|
2015-09-29 17:19:35 +03:00
|
|
|
BRANCH_FLAGS
|
2015-09-29 16:22:05 +03:00
|
|
|
|
tracing: Use TRACE_FLAGS macro to keep enums and strings matched
Use a cute little macro trick to keep the names of the trace flags file
guaranteed to match the corresponding masks.
The macro TRACE_FLAGS is defined as a serious of enum names followed by
the string name of the file that matches it. For example:
#define TRACE_FLAGS \
C(PRINT_PARENT, "print-parent"), \
C(SYM_OFFSET, "sym-offset"), \
C(SYM_ADDR, "sym-addr"), \
C(VERBOSE, "verbose"),
Now we can define the following:
#undef C
#define C(a, b) TRACE_ITER_##a##_BIT
enum trace_iterator_bits { TRACE_FLAGS };
The above creates:
enum trace_iterator_bits {
TRACE_ITER_PRINT_PARENT_BIT,
TRACE_ITER_SYM_OFFSET_BIT,
TRACE_ITER_SYM_ADDR_BIT,
TRACE_ITER_VERBOSE_BIT,
};
Then we can redefine C as:
#undef C
#define C(a, b) TRACE_ITER_##a = (1 << TRACE_ITER_##a##_BIT)
enum trace_iterator_flags { TRACE_FLAGS };
Which creates:
enum trace_iterator_flags {
TRACE_ITER_PRINT_PARENT = (1 << TRACE_ITER_PRINT_PARENT_BIT),
TRACE_ITER_SYM_OFFSET = (1 << TRACE_ITER_SYM_OFFSET_BIT),
TRACE_ITER_SYM_ADDR = (1 << TRACE_ITER_SYM_ADDR_BIT),
TRACE_ITER_VERBOSE = (1 << TRACE_ITER_VERBOSE_BIT),
};
Then finally we can create the list of file names:
#undef C
#define C(a, b) b
static const char *trace_options[] = {
TRACE_FLAGS
NULL
};
Which creates:
static const char *trace_options[] = {
"print-parent",
"sym-offset",
"sym-addr",
"verbose",
NULL
};
The importance of this is that the strings match the bit index.
trace_options[TRACE_ITER_SYM_ADDR_BIT] == "sym-addr"
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2015-09-29 16:43:30 +03:00
|
|
|
/*
|
|
|
|
* By defining C, we can make TRACE_FLAGS a list of bit names
|
|
|
|
* that will define the bits for the flag masks.
|
|
|
|
*/
|
|
|
|
#undef C
|
|
|
|
#define C(a, b) TRACE_ITER_##a##_BIT
|
|
|
|
|
2015-09-30 01:13:33 +03:00
|
|
|
enum trace_iterator_bits {
|
|
|
|
TRACE_FLAGS
|
|
|
|
/* Make sure we don't go more than we have bits for */
|
|
|
|
TRACE_ITER_LAST_BIT
|
|
|
|
};
|
tracing: Use TRACE_FLAGS macro to keep enums and strings matched
Use a cute little macro trick to keep the names of the trace flags file
guaranteed to match the corresponding masks.
The macro TRACE_FLAGS is defined as a serious of enum names followed by
the string name of the file that matches it. For example:
#define TRACE_FLAGS \
C(PRINT_PARENT, "print-parent"), \
C(SYM_OFFSET, "sym-offset"), \
C(SYM_ADDR, "sym-addr"), \
C(VERBOSE, "verbose"),
Now we can define the following:
#undef C
#define C(a, b) TRACE_ITER_##a##_BIT
enum trace_iterator_bits { TRACE_FLAGS };
The above creates:
enum trace_iterator_bits {
TRACE_ITER_PRINT_PARENT_BIT,
TRACE_ITER_SYM_OFFSET_BIT,
TRACE_ITER_SYM_ADDR_BIT,
TRACE_ITER_VERBOSE_BIT,
};
Then we can redefine C as:
#undef C
#define C(a, b) TRACE_ITER_##a = (1 << TRACE_ITER_##a##_BIT)
enum trace_iterator_flags { TRACE_FLAGS };
Which creates:
enum trace_iterator_flags {
TRACE_ITER_PRINT_PARENT = (1 << TRACE_ITER_PRINT_PARENT_BIT),
TRACE_ITER_SYM_OFFSET = (1 << TRACE_ITER_SYM_OFFSET_BIT),
TRACE_ITER_SYM_ADDR = (1 << TRACE_ITER_SYM_ADDR_BIT),
TRACE_ITER_VERBOSE = (1 << TRACE_ITER_VERBOSE_BIT),
};
Then finally we can create the list of file names:
#undef C
#define C(a, b) b
static const char *trace_options[] = {
TRACE_FLAGS
NULL
};
Which creates:
static const char *trace_options[] = {
"print-parent",
"sym-offset",
"sym-addr",
"verbose",
NULL
};
The importance of this is that the strings match the bit index.
trace_options[TRACE_ITER_SYM_ADDR_BIT] == "sym-addr"
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2015-09-29 16:43:30 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* By redefining C, we can make TRACE_FLAGS a list of masks that
|
|
|
|
* use the bits as defined above.
|
|
|
|
*/
|
|
|
|
#undef C
|
|
|
|
#define C(a, b) TRACE_ITER_##a = (1 << TRACE_ITER_##a##_BIT)
|
|
|
|
|
|
|
|
enum trace_iterator_flags { TRACE_FLAGS };
|
2008-05-12 23:20:52 +04:00
|
|
|
|
2008-11-11 09:14:25 +03: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 22:16:30 +04:00
|
|
|
extern struct tracer nop_trace;
|
|
|
|
|
2008-11-12 23:24:24 +03:00
|
|
|
#ifdef CONFIG_BRANCH_TRACER
|
2008-11-12 23:24:24 +03:00
|
|
|
extern int enable_branch_tracing(struct trace_array *tr);
|
|
|
|
extern void disable_branch_tracing(void);
|
|
|
|
static inline int trace_branch_enable(struct trace_array *tr)
|
2008-11-12 08:14:40 +03:00
|
|
|
{
|
2015-09-30 16:42:05 +03:00
|
|
|
if (tr->trace_flags & TRACE_ITER_BRANCH)
|
2008-11-12 23:24:24 +03:00
|
|
|
return enable_branch_tracing(tr);
|
2008-11-12 08:14:40 +03:00
|
|
|
return 0;
|
|
|
|
}
|
2008-11-12 23:24:24 +03:00
|
|
|
static inline void trace_branch_disable(void)
|
2008-11-12 08:14:40 +03:00
|
|
|
{
|
|
|
|
/* due to races, always disable */
|
2008-11-12 23:24:24 +03:00
|
|
|
disable_branch_tracing();
|
2008-11-12 08:14:40 +03:00
|
|
|
}
|
|
|
|
#else
|
2008-11-12 23:24:24 +03:00
|
|
|
static inline int trace_branch_enable(struct trace_array *tr)
|
2008-11-12 08:14:40 +03:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2008-11-12 23:24:24 +03:00
|
|
|
static inline void trace_branch_disable(void)
|
2008-11-12 08:14:40 +03:00
|
|
|
{
|
|
|
|
}
|
2008-11-12 23:24:24 +03:00
|
|
|
#endif /* CONFIG_BRANCH_TRACER */
|
2008-11-12 08:14:40 +03:00
|
|
|
|
2009-03-11 21:33:00 +03:00
|
|
|
/* set ring buffers to default size if not already done so */
|
|
|
|
int tracing_update_buffers(void);
|
|
|
|
|
2009-03-22 11:30:39 +03:00
|
|
|
struct ftrace_event_field {
|
|
|
|
struct list_head link;
|
2013-02-28 05:41:37 +04:00
|
|
|
const char *name;
|
|
|
|
const char *type;
|
2009-08-07 06:33:02 +04:00
|
|
|
int filter_type;
|
2009-03-22 11:30:39 +03:00
|
|
|
int offset;
|
|
|
|
int size;
|
2009-04-28 12:04:53 +04:00
|
|
|
int is_signed;
|
2009-03-22 11:30:39 +03:00
|
|
|
};
|
|
|
|
|
2018-03-09 21:19:28 +03:00
|
|
|
struct prog_entry;
|
|
|
|
|
2009-04-28 12:04:47 +04:00
|
|
|
struct event_filter {
|
2018-03-09 21:19:28 +03:00
|
|
|
struct prog_entry __rcu *prog;
|
|
|
|
char *filter_string;
|
2009-04-28 12:04:47 +04:00
|
|
|
};
|
|
|
|
|
2009-03-22 11:31:17 +03:00
|
|
|
struct event_subsystem {
|
|
|
|
struct list_head list;
|
|
|
|
const char *name;
|
2009-07-20 06:20:53 +04:00
|
|
|
struct event_filter *filter;
|
2011-07-05 19:36:06 +04:00
|
|
|
int ref_count;
|
2009-03-22 11:31:17 +03:00
|
|
|
};
|
|
|
|
|
2015-05-13 21:59:40 +03:00
|
|
|
struct trace_subsystem_dir {
|
2012-05-04 07:09:03 +04:00
|
|
|
struct list_head list;
|
|
|
|
struct event_subsystem *subsystem;
|
|
|
|
struct trace_array *tr;
|
|
|
|
struct dentry *entry;
|
|
|
|
int ref_count;
|
|
|
|
int nr_events;
|
|
|
|
};
|
|
|
|
|
2016-04-27 17:13:46 +03:00
|
|
|
extern int call_filter_check_discard(struct trace_event_call *call, void *rec,
|
2019-12-13 21:58:57 +03:00
|
|
|
struct trace_buffer *buffer,
|
2016-04-27 17:13:46 +03:00
|
|
|
struct ring_buffer_event *event);
|
2016-04-28 19:04:13 +03:00
|
|
|
|
|
|
|
void trace_buffer_unlock_commit_regs(struct trace_array *tr,
|
2019-12-13 21:58:57 +03:00
|
|
|
struct trace_buffer *buffer,
|
2016-04-28 19:04:13 +03:00
|
|
|
struct ring_buffer_event *event,
|
|
|
|
unsigned long flags, int pc,
|
|
|
|
struct pt_regs *regs);
|
2016-04-30 00:44:01 +03:00
|
|
|
|
|
|
|
static inline void trace_buffer_unlock_commit(struct trace_array *tr,
|
2019-12-13 21:58:57 +03:00
|
|
|
struct trace_buffer *buffer,
|
2016-04-30 00:44:01 +03:00
|
|
|
struct ring_buffer_event *event,
|
|
|
|
unsigned long flags, int pc)
|
|
|
|
{
|
|
|
|
trace_buffer_unlock_commit_regs(tr, buffer, event, flags, pc, NULL);
|
|
|
|
}
|
|
|
|
|
2016-05-04 00:15:43 +03:00
|
|
|
DECLARE_PER_CPU(struct ring_buffer_event *, trace_buffered_event);
|
|
|
|
DECLARE_PER_CPU(int, trace_buffered_event_cnt);
|
|
|
|
void trace_buffered_event_disable(void);
|
|
|
|
void trace_buffered_event_enable(void);
|
|
|
|
|
|
|
|
static inline void
|
2019-12-13 21:58:57 +03:00
|
|
|
__trace_event_discard_commit(struct trace_buffer *buffer,
|
2016-05-04 00:15:43 +03:00
|
|
|
struct ring_buffer_event *event)
|
|
|
|
{
|
|
|
|
if (this_cpu_read(trace_buffered_event) == event) {
|
|
|
|
/* Simply release the temp buffer */
|
|
|
|
this_cpu_dec(trace_buffered_event_cnt);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
ring_buffer_discard_commit(buffer, event);
|
|
|
|
}
|
|
|
|
|
2016-04-27 04:22:22 +03:00
|
|
|
/*
|
|
|
|
* Helper function for event_trigger_unlock_commit{_regs}().
|
|
|
|
* If there are event triggers attached to this event that requires
|
|
|
|
* filtering against its fields, then they wil be called as the
|
|
|
|
* entry already holds the field information of the current event.
|
|
|
|
*
|
|
|
|
* It also checks if the event should be discarded or not.
|
|
|
|
* It is to be discarded if the event is soft disabled and the
|
|
|
|
* event was only recorded to process triggers, or if the event
|
|
|
|
* filter is active and this event did not match the filters.
|
|
|
|
*
|
|
|
|
* Returns true if the event is discarded, false otherwise.
|
|
|
|
*/
|
|
|
|
static inline bool
|
|
|
|
__event_trigger_test_discard(struct trace_event_file *file,
|
2019-12-13 21:58:57 +03:00
|
|
|
struct trace_buffer *buffer,
|
2016-04-27 04:22:22 +03:00
|
|
|
struct ring_buffer_event *event,
|
|
|
|
void *entry,
|
|
|
|
enum event_trigger_type *tt)
|
|
|
|
{
|
|
|
|
unsigned long eflags = file->flags;
|
|
|
|
|
|
|
|
if (eflags & EVENT_FILE_FL_TRIGGER_COND)
|
2018-01-16 05:51:42 +03:00
|
|
|
*tt = event_triggers_call(file, entry, event);
|
2016-04-27 04:22:22 +03:00
|
|
|
|
2016-04-27 18:09:42 +03:00
|
|
|
if (test_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags) ||
|
|
|
|
(unlikely(file->flags & EVENT_FILE_FL_FILTERED) &&
|
|
|
|
!filter_match_preds(file->filter, entry))) {
|
2016-05-04 00:15:43 +03:00
|
|
|
__trace_event_discard_commit(buffer, event);
|
2016-04-27 18:09:42 +03:00
|
|
|
return true;
|
|
|
|
}
|
2016-04-27 04:22:22 +03:00
|
|
|
|
2016-04-27 18:09:42 +03:00
|
|
|
return false;
|
2016-04-27 04:22:22 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* event_trigger_unlock_commit - handle triggers and finish event commit
|
|
|
|
* @file: The file pointer assoctiated to the event
|
|
|
|
* @buffer: The ring buffer that the event is being written to
|
|
|
|
* @event: The event meta data in the ring buffer
|
|
|
|
* @entry: The event itself
|
|
|
|
* @irq_flags: The state of the interrupts at the start of the event
|
|
|
|
* @pc: The state of the preempt count at the start of the event.
|
|
|
|
*
|
|
|
|
* This is a helper function to handle triggers that require data
|
|
|
|
* from the event itself. It also tests the event against filters and
|
|
|
|
* if the event is soft disabled and should be discarded.
|
|
|
|
*/
|
|
|
|
static inline void
|
|
|
|
event_trigger_unlock_commit(struct trace_event_file *file,
|
2019-12-13 21:58:57 +03:00
|
|
|
struct trace_buffer *buffer,
|
2016-04-27 04:22:22 +03:00
|
|
|
struct ring_buffer_event *event,
|
|
|
|
void *entry, unsigned long irq_flags, int pc)
|
|
|
|
{
|
|
|
|
enum event_trigger_type tt = ETT_NONE;
|
|
|
|
|
|
|
|
if (!__event_trigger_test_discard(file, buffer, event, entry, &tt))
|
|
|
|
trace_buffer_unlock_commit(file->tr, buffer, event, irq_flags, pc);
|
|
|
|
|
|
|
|
if (tt)
|
2018-05-07 23:02:14 +03:00
|
|
|
event_triggers_post_call(file, tt);
|
2016-04-27 04:22:22 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* event_trigger_unlock_commit_regs - handle triggers and finish event commit
|
|
|
|
* @file: The file pointer assoctiated to the event
|
|
|
|
* @buffer: The ring buffer that the event is being written to
|
|
|
|
* @event: The event meta data in the ring buffer
|
|
|
|
* @entry: The event itself
|
|
|
|
* @irq_flags: The state of the interrupts at the start of the event
|
|
|
|
* @pc: The state of the preempt count at the start of the event.
|
|
|
|
*
|
|
|
|
* This is a helper function to handle triggers that require data
|
|
|
|
* from the event itself. It also tests the event against filters and
|
|
|
|
* if the event is soft disabled and should be discarded.
|
|
|
|
*
|
|
|
|
* Same as event_trigger_unlock_commit() but calls
|
|
|
|
* trace_buffer_unlock_commit_regs() instead of trace_buffer_unlock_commit().
|
|
|
|
*/
|
|
|
|
static inline void
|
|
|
|
event_trigger_unlock_commit_regs(struct trace_event_file *file,
|
2019-12-13 21:58:57 +03:00
|
|
|
struct trace_buffer *buffer,
|
2016-04-27 04:22:22 +03:00
|
|
|
struct ring_buffer_event *event,
|
|
|
|
void *entry, unsigned long irq_flags, int pc,
|
|
|
|
struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
enum event_trigger_type tt = ETT_NONE;
|
|
|
|
|
|
|
|
if (!__event_trigger_test_discard(file, buffer, event, entry, &tt))
|
|
|
|
trace_buffer_unlock_commit_regs(file->tr, buffer, event,
|
|
|
|
irq_flags, pc, regs);
|
|
|
|
|
|
|
|
if (tt)
|
2018-05-07 23:02:14 +03:00
|
|
|
event_triggers_post_call(file, tt);
|
2016-04-27 04:22:22 +03:00
|
|
|
}
|
|
|
|
|
2011-01-28 06:54:33 +03:00
|
|
|
#define FILTER_PRED_INVALID ((unsigned short)-1)
|
|
|
|
#define FILTER_PRED_IS_RIGHT (1 << 15)
|
2011-01-28 07:16:51 +03:00
|
|
|
#define FILTER_PRED_FOLD (1 << 15)
|
2011-01-28 06:54:33 +03:00
|
|
|
|
2011-01-28 07:21:34 +03:00
|
|
|
/*
|
|
|
|
* The max preds is the size of unsigned short with
|
|
|
|
* two flags at the MSBs. One bit is used for both the IS_RIGHT
|
|
|
|
* and FOLD flags. The other is reserved.
|
|
|
|
*
|
|
|
|
* 2^14 preds is way more than enough.
|
|
|
|
*/
|
|
|
|
#define MAX_FILTER_PRED 16384
|
2011-01-28 07:19:49 +03:00
|
|
|
|
2009-03-22 11:31:04 +03:00
|
|
|
struct filter_pred;
|
2009-09-24 23:10:44 +04:00
|
|
|
struct regex;
|
2009-03-22 11:31:04 +03:00
|
|
|
|
2011-01-28 06:37:09 +03:00
|
|
|
typedef int (*filter_pred_fn_t) (struct filter_pred *pred, void *event);
|
2009-03-22 11:31:04 +03:00
|
|
|
|
2009-09-24 23:10:44 +04:00
|
|
|
typedef int (*regex_match_func)(char *str, struct regex *r, int len);
|
|
|
|
|
2009-09-24 23:31:51 +04:00
|
|
|
enum regex_type {
|
2009-10-15 07:21:12 +04:00
|
|
|
MATCH_FULL = 0,
|
2009-09-24 23:31:51 +04:00
|
|
|
MATCH_FRONT_ONLY,
|
|
|
|
MATCH_MIDDLE_ONLY,
|
|
|
|
MATCH_END_ONLY,
|
2016-10-05 14:58:15 +03:00
|
|
|
MATCH_GLOB,
|
ftrace: Allow enabling of filters via index of available_filter_functions
Enabling of large number of functions by echoing in a large subset of the
functions in available_filter_functions can take a very long time. The
process requires testing all functions registered by the function tracer
(which is in the 10s of thousands), and doing a kallsyms lookup to convert
the ip address into a name, then comparing that name with the string passed
in.
When a function causes the function tracer to crash the system, a binary
bisect of the available_filter_functions can be done to find the culprit.
But this requires passing in half of the functions in
available_filter_functions over and over again, which makes it basically a
O(n^2) operation. With 40,000 functions, that ends up bing 1,600,000,000
opertions! And enabling this can take over 20 minutes.
As a quick speed up, if a number is passed into one of the filter files,
instead of doing a search, it just enables the function at the corresponding
line of the available_filter_functions file. That is:
# echo 50 > set_ftrace_filter
# cat set_ftrace_filter
x86_pmu_commit_txn
# head -50 available_filter_functions | tail -1
x86_pmu_commit_txn
This allows setting of half the available_filter_functions to take place in
less than a second!
# time seq 20000 > set_ftrace_filter
real 0m0.042s
user 0m0.005s
sys 0m0.015s
# wc -l set_ftrace_filter
20000 set_ftrace_filter
Signed-off-by: Steven Rostedt (VMware) <rostedt@goodmis.org>
2019-02-11 23:00:48 +03:00
|
|
|
MATCH_INDEX,
|
2009-09-24 23:31:51 +04:00
|
|
|
};
|
|
|
|
|
2009-09-24 23:10:44 +04:00
|
|
|
struct regex {
|
|
|
|
char pattern[MAX_FILTER_STR_VAL];
|
|
|
|
int len;
|
|
|
|
int field_len;
|
|
|
|
regex_match_func match;
|
|
|
|
};
|
|
|
|
|
2009-03-22 11:31:04 +03:00
|
|
|
struct filter_pred {
|
2009-09-24 23:10:44 +04:00
|
|
|
filter_pred_fn_t fn;
|
|
|
|
u64 val;
|
|
|
|
struct regex regex;
|
2011-08-11 18:25:47 +04:00
|
|
|
unsigned short *ops;
|
2011-08-11 18:25:54 +04:00
|
|
|
struct ftrace_event_field *field;
|
2009-09-24 23:10:44 +04:00
|
|
|
int offset;
|
2018-03-09 21:19:28 +03:00
|
|
|
int not;
|
2009-09-24 23:10:44 +04:00
|
|
|
int op;
|
2009-03-22 11:31:04 +03:00
|
|
|
};
|
|
|
|
|
2015-12-10 21:50:43 +03:00
|
|
|
static inline bool is_string_field(struct ftrace_event_field *field)
|
|
|
|
{
|
|
|
|
return field->filter_type == FILTER_DYN_STRING ||
|
|
|
|
field->filter_type == FILTER_STATIC_STRING ||
|
2017-02-08 21:36:37 +03:00
|
|
|
field->filter_type == FILTER_PTR_STRING ||
|
|
|
|
field->filter_type == FILTER_COMM;
|
2015-12-10 21:50:43 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool is_function_field(struct ftrace_event_field *field)
|
|
|
|
{
|
|
|
|
return field->filter_type == FILTER_TRACE_FN;
|
|
|
|
}
|
|
|
|
|
2009-09-24 23:31:51 +04:00
|
|
|
extern enum regex_type
|
|
|
|
filter_parse_regex(char *buff, int len, char **search, int *not);
|
2015-05-05 17:09:53 +03:00
|
|
|
extern void print_event_filter(struct trace_event_file *file,
|
2009-03-24 10:14:31 +03:00
|
|
|
struct trace_seq *s);
|
2015-05-05 17:09:53 +03:00
|
|
|
extern int apply_event_filter(struct trace_event_file *file,
|
tracing/filters: a better event parser
Replace the current event parser hack with a better one. Filters are
no longer specified predicate by predicate, but all at once and can
use parens and any of the following operators:
numeric fields:
==, !=, <, <=, >, >=
string fields:
==, !=
predicates can be combined with the logical operators:
&&, ||
examples:
"common_preempt_count > 4" > filter
"((sig >= 10 && sig < 15) || sig == 17) && comm != bash" > filter
If there was an error, the erroneous string along with an error
message can be seen by looking at the filter e.g.:
((sig >= 10 && sig < 15) || dsig == 17) && comm != bash
^
parse_error: Field not found
Currently the caret for an error always appears at the beginning of
the filter; a real position should be used, but the error message
should be useful even without it.
To clear a filter, '0' can be written to the filter file.
Filters can also be set or cleared for a complete subsystem by writing
the same filter as would be written to an individual event to the
filter file at the root of the subsytem. Note however, that if any
event in the subsystem lacks a field specified in the filter being
set, the set will fail and all filters in the subsytem are
automatically cleared. This change from the previous version was made
because using only the fields that happen to exist for a given event
would most likely result in a meaningless filter.
Because the logical operators are now implemented as predicates, the
maximum number of predicates in a filter was increased from 8 to 16.
[ Impact: add new, extended trace-filter implementation ]
Signed-off-by: Tom Zanussi <tzanussi@gmail.com>
Acked-by: Steven Rostedt <rostedt@goodmis.org>
Cc: fweisbec@gmail.com
Cc: Li Zefan <lizf@cn.fujitsu.com>
LKML-Reference: <1240905899.6416.121.camel@tropicana>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-04-28 12:04:59 +04:00
|
|
|
char *filter_string);
|
2015-05-13 21:59:40 +03:00
|
|
|
extern int apply_subsystem_event_filter(struct trace_subsystem_dir *dir,
|
tracing/filters: a better event parser
Replace the current event parser hack with a better one. Filters are
no longer specified predicate by predicate, but all at once and can
use parens and any of the following operators:
numeric fields:
==, !=, <, <=, >, >=
string fields:
==, !=
predicates can be combined with the logical operators:
&&, ||
examples:
"common_preempt_count > 4" > filter
"((sig >= 10 && sig < 15) || sig == 17) && comm != bash" > filter
If there was an error, the erroneous string along with an error
message can be seen by looking at the filter e.g.:
((sig >= 10 && sig < 15) || dsig == 17) && comm != bash
^
parse_error: Field not found
Currently the caret for an error always appears at the beginning of
the filter; a real position should be used, but the error message
should be useful even without it.
To clear a filter, '0' can be written to the filter file.
Filters can also be set or cleared for a complete subsystem by writing
the same filter as would be written to an individual event to the
filter file at the root of the subsytem. Note however, that if any
event in the subsystem lacks a field specified in the filter being
set, the set will fail and all filters in the subsytem are
automatically cleared. This change from the previous version was made
because using only the fields that happen to exist for a given event
would most likely result in a meaningless filter.
Because the logical operators are now implemented as predicates, the
maximum number of predicates in a filter was increased from 8 to 16.
[ Impact: add new, extended trace-filter implementation ]
Signed-off-by: Tom Zanussi <tzanussi@gmail.com>
Acked-by: Steven Rostedt <rostedt@goodmis.org>
Cc: fweisbec@gmail.com
Cc: Li Zefan <lizf@cn.fujitsu.com>
LKML-Reference: <1240905899.6416.121.camel@tropicana>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-04-28 12:04:59 +04:00
|
|
|
char *filter_string);
|
|
|
|
extern void print_subsystem_event_filter(struct event_subsystem *system,
|
2009-04-17 09:27:08 +04:00
|
|
|
struct trace_seq *s);
|
2009-08-07 06:33:02 +04:00
|
|
|
extern int filter_assign_type(const char *type);
|
2019-04-01 23:07:48 +03:00
|
|
|
extern int create_event_filter(struct trace_array *tr,
|
|
|
|
struct trace_event_call *call,
|
tracing: Add and use generic set_trigger_filter() implementation
Add a generic event_command.set_trigger_filter() op implementation and
have the current set of trigger commands use it - this essentially
gives them all support for filters.
Syntactically, filters are supported by adding 'if <filter>' just
after the command, in which case only events matching the filter will
invoke the trigger. For example, to add a filter to an
enable/disable_event command:
echo 'enable_event:system:event if common_pid == 999' > \
.../othersys/otherevent/trigger
The above command will only enable the system:event event if the
common_pid field in the othersys:otherevent event is 999.
As another example, to add a filter to a stacktrace command:
echo 'stacktrace if common_pid == 999' > \
.../somesys/someevent/trigger
The above command will only trigger a stacktrace if the common_pid
field in the event is 999.
The filter syntax is the same as that described in the 'Event
filtering' section of Documentation/trace/events.txt.
Because triggers can now use filters, the trigger-invoking logic needs
to be moved in those cases - e.g. for ftrace_raw_event_calls, if a
trigger has a filter associated with it, the trigger invocation now
needs to happen after the { assign; } part of the call, in order for
the trigger condition to be tested.
There's still a SOFT_DISABLED-only check at the top of e.g. the
ftrace_raw_events function, so when an event is soft disabled but not
because of the presence of a trigger, the original SOFT_DISABLED
behavior remains unchanged.
There's also a bit of trickiness in that some triggers need to avoid
being invoked while an event is currently in the process of being
logged, since the trigger may itself log data into the trace buffer.
Thus we make sure the current event is committed before invoking those
triggers. To do that, we split the trigger invocation in two - the
first part (event_triggers_call()) checks the filter using the current
trace record; if a command has the post_trigger flag set, it sets a
bit for itself in the return value, otherwise it directly invoks the
trigger. Once all commands have been either invoked or set their
return flag, event_triggers_call() returns. The current record is
then either committed or discarded; if any commands have deferred
their triggers, those commands are finally invoked following the close
of the current event by event_triggers_post_call().
To simplify the above and make it more efficient, the TRIGGER_COND bit
is introduced, which is set only if a soft-disabled trigger needs to
use the log record for filter testing or needs to wait until the
current log record is closed.
The syscall event invocation code is also changed in analogous ways.
Because event triggers need to be able to create and free filters,
this also adds a couple external wrappers for the existing
create_filter and free_filter functions, which are too generic to be
made extern functions themselves.
Link: http://lkml.kernel.org/r/7164930759d8719ef460357f143d995406e4eead.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 17:59:29 +04:00
|
|
|
char *filter_str, bool set_str,
|
|
|
|
struct event_filter **filterp);
|
|
|
|
extern void free_event_filter(struct event_filter *filter);
|
2009-03-22 11:31:04 +03:00
|
|
|
|
2013-03-11 11:13:42 +04:00
|
|
|
struct ftrace_event_field *
|
2015-05-05 18:45:27 +03:00
|
|
|
trace_find_event_field(struct trace_event_call *call, char *name);
|
2010-04-22 18:35:55 +04:00
|
|
|
|
2010-07-02 07:07:32 +04:00
|
|
|
extern void trace_event_enable_cmd_record(bool enable);
|
2017-06-27 05:01:55 +03:00
|
|
|
extern void trace_event_enable_tgid_record(bool enable);
|
|
|
|
|
2018-05-08 22:09:27 +03:00
|
|
|
extern int event_trace_init(void);
|
2012-08-04 00:10:49 +04:00
|
|
|
extern int event_trace_add_tracer(struct dentry *parent, struct trace_array *tr);
|
2012-08-08 00:14:16 +04:00
|
|
|
extern int event_trace_del_tracer(struct trace_array *tr);
|
2010-07-02 07:07:32 +04:00
|
|
|
|
2018-05-08 22:06:38 +03:00
|
|
|
extern struct trace_event_file *__find_event_file(struct trace_array *tr,
|
|
|
|
const char *system,
|
|
|
|
const char *event);
|
2015-05-05 17:09:53 +03:00
|
|
|
extern struct trace_event_file *find_event_file(struct trace_array *tr,
|
|
|
|
const char *system,
|
|
|
|
const char *event);
|
2013-10-24 17:59:28 +04: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 17:59:24 +04:00
|
|
|
static inline void *event_file_data(struct file *filp)
|
|
|
|
{
|
locking/atomics: COCCINELLE/treewide: Convert trivial ACCESS_ONCE() patterns to READ_ONCE()/WRITE_ONCE()
Please do not apply this to mainline directly, instead please re-run the
coccinelle script shown below and apply its output.
For several reasons, it is desirable to use {READ,WRITE}_ONCE() in
preference to ACCESS_ONCE(), and new code is expected to use one of the
former. So far, there's been no reason to change most existing uses of
ACCESS_ONCE(), as these aren't harmful, and changing them results in
churn.
However, for some features, the read/write distinction is critical to
correct operation. To distinguish these cases, separate read/write
accessors must be used. This patch migrates (most) remaining
ACCESS_ONCE() instances to {READ,WRITE}_ONCE(), using the following
coccinelle script:
----
// Convert trivial ACCESS_ONCE() uses to equivalent READ_ONCE() and
// WRITE_ONCE()
// $ make coccicheck COCCI=/home/mark/once.cocci SPFLAGS="--include-headers" MODE=patch
virtual patch
@ depends on patch @
expression E1, E2;
@@
- ACCESS_ONCE(E1) = E2
+ WRITE_ONCE(E1, E2)
@ depends on patch @
expression E;
@@
- ACCESS_ONCE(E)
+ READ_ONCE(E)
----
Signed-off-by: Mark Rutland <mark.rutland@arm.com>
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: davem@davemloft.net
Cc: linux-arch@vger.kernel.org
Cc: mpe@ellerman.id.au
Cc: shuah@kernel.org
Cc: snitzer@redhat.com
Cc: thor.thayer@linux.intel.com
Cc: tj@kernel.org
Cc: viro@zeniv.linux.org.uk
Cc: will.deacon@arm.com
Link: http://lkml.kernel.org/r/1508792849-3115-19-git-send-email-paulmck@linux.vnet.ibm.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2017-10-24 00:07:29 +03:00
|
|
|
return READ_ONCE(file_inode(filp)->i_private);
|
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 17:59:24 +04:00
|
|
|
}
|
|
|
|
|
2009-05-06 06:33:45 +04:00
|
|
|
extern struct mutex event_mutex;
|
2009-04-10 21:52:20 +04:00
|
|
|
extern struct list_head ftrace_events;
|
2009-03-19 22:26:15 +03: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 17:59:24 +04:00
|
|
|
extern const struct file_operations event_trigger_fops;
|
tracing: Add 'hist' event trigger command
'hist' triggers allow users to continually aggregate trace events,
which can then be viewed afterwards by simply reading a 'hist' file
containing the aggregation in a human-readable format.
The basic idea is very simple and boils down to a mechanism whereby
trace events, rather than being exhaustively dumped in raw form and
viewed directly, are automatically 'compressed' into meaningful tables
completely defined by the user.
This is done strictly via single-line command-line commands and
without the aid of any kind of programming language or interpreter.
A surprising number of typical use cases can be accomplished by users
via this simple mechanism. In fact, a large number of the tasks that
users typically do using the more complicated script-based tracing
tools, at least during the initial stages of an investigation, can be
accomplished by simply specifying a set of keys and values to be used
in the creation of a hash table.
The Linux kernel trace event subsystem happens to provide an extensive
list of keys and values ready-made for such a purpose in the form of
the event format files associated with each trace event. By simply
consulting the format file for field names of interest and by plugging
them into the hist trigger command, users can create an endless number
of useful aggregations to help with investigating various properties
of the system. See Documentation/trace/events.txt for examples.
hist triggers are implemented on top of the existing event trigger
infrastructure, and as such are consistent with the existing triggers
from a user's perspective as well.
The basic syntax follows the existing trigger syntax. Users start an
aggregation by writing a 'hist' trigger to the event of interest's
trigger file:
# echo hist:keys=xxx [ if filter] > event/trigger
Once a hist trigger has been set up, by default it continually
aggregates every matching event into a hash table using the event key
and a value field named 'hitcount'.
To view the aggregation at any point in time, simply read the 'hist'
file in the same directory as the 'trigger' file:
# cat event/hist
The detailed syntax provides additional options for user control, and
is described exhaustively in Documentation/trace/events.txt and in the
virtual tracing/README file in the tracing subsystem.
Link: http://lkml.kernel.org/r/72d263b5e1853fe9c314953b65833c3aa75479f2.1457029949.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Tested-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Reviewed-by: Namhyung Kim <namhyung@kernel.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2016-03-03 21:54:42 +03:00
|
|
|
extern const struct file_operations event_hist_fops;
|
tracing: Introduce trace event injection
We have been trying to use rasdaemon to monitor hardware errors like
correctable memory errors. rasdaemon uses trace events to monitor
various hardware errors. In order to test it, we have to inject some
hardware errors, unfortunately not all of them provide error
injections. MCE does provide a way to inject MCE errors, but errors
like PCI error and devlink error don't, it is not easy to add error
injection to each of them. Instead, it is relatively easier to just
allow users to inject trace events in a generic way so that all trace
events can be injected.
This patch introduces trace event injection, where a new 'inject' is
added to each tracepoint directory. Users could write into this file
with key=value pairs to specify the value of each fields of the trace
event, all unspecified fields are set to zero values by default.
For example, for the net/net_dev_queue tracepoint, we can inject:
INJECT=/sys/kernel/debug/tracing/events/net/net_dev_queue/inject
echo "" > $INJECT
echo "name='test'" > $INJECT
echo "name='test' len=1024" > $INJECT
cat /sys/kernel/debug/tracing/trace
...
<...>-614 [000] .... 36.571483: net_dev_queue: dev= skbaddr=00000000fbf338c2 len=0
<...>-614 [001] .... 136.588252: net_dev_queue: dev=test skbaddr=00000000fbf338c2 len=0
<...>-614 [001] .N.. 208.431878: net_dev_queue: dev=test skbaddr=00000000fbf338c2 len=1024
Triggers could be triggered as usual too:
echo "stacktrace if len == 1025" > /sys/kernel/debug/tracing/events/net/net_dev_queue/trigger
echo "len=1025" > $INJECT
cat /sys/kernel/debug/tracing/trace
...
bash-614 [000] .... 36.571483: net_dev_queue: dev= skbaddr=00000000fbf338c2 len=0
bash-614 [001] .... 136.588252: net_dev_queue: dev=test skbaddr=00000000fbf338c2 len=0
bash-614 [001] .N.. 208.431878: net_dev_queue: dev=test skbaddr=00000000fbf338c2 len=1024
bash-614 [001] .N.1 284.236349: <stack trace>
=> event_inject_write
=> vfs_write
=> ksys_write
=> do_syscall_64
=> entry_SYSCALL_64_after_hwframe
The only thing that can't be injected is string pointers as they
require constant string pointers, this can't be done at run time.
Link: http://lkml.kernel.org/r/20191130045218.18979-1-xiyou.wangcong@gmail.com
Cc: Ingo Molnar <mingo@redhat.com>
Signed-off-by: Cong Wang <xiyou.wangcong@gmail.com>
Signed-off-by: Steven Rostedt (VMware) <rostedt@goodmis.org>
2019-11-30 07:52:18 +03:00
|
|
|
extern const struct file_operations event_inject_fops;
|
tracing: Add 'hist' event trigger command
'hist' triggers allow users to continually aggregate trace events,
which can then be viewed afterwards by simply reading a 'hist' file
containing the aggregation in a human-readable format.
The basic idea is very simple and boils down to a mechanism whereby
trace events, rather than being exhaustively dumped in raw form and
viewed directly, are automatically 'compressed' into meaningful tables
completely defined by the user.
This is done strictly via single-line command-line commands and
without the aid of any kind of programming language or interpreter.
A surprising number of typical use cases can be accomplished by users
via this simple mechanism. In fact, a large number of the tasks that
users typically do using the more complicated script-based tracing
tools, at least during the initial stages of an investigation, can be
accomplished by simply specifying a set of keys and values to be used
in the creation of a hash table.
The Linux kernel trace event subsystem happens to provide an extensive
list of keys and values ready-made for such a purpose in the form of
the event format files associated with each trace event. By simply
consulting the format file for field names of interest and by plugging
them into the hist trigger command, users can create an endless number
of useful aggregations to help with investigating various properties
of the system. See Documentation/trace/events.txt for examples.
hist triggers are implemented on top of the existing event trigger
infrastructure, and as such are consistent with the existing triggers
from a user's perspective as well.
The basic syntax follows the existing trigger syntax. Users start an
aggregation by writing a 'hist' trigger to the event of interest's
trigger file:
# echo hist:keys=xxx [ if filter] > event/trigger
Once a hist trigger has been set up, by default it continually
aggregates every matching event into a hash table using the event key
and a value field named 'hitcount'.
To view the aggregation at any point in time, simply read the 'hist'
file in the same directory as the 'trigger' file:
# cat event/hist
The detailed syntax provides additional options for user control, and
is described exhaustively in Documentation/trace/events.txt and in the
virtual tracing/README file in the tracing subsystem.
Link: http://lkml.kernel.org/r/72d263b5e1853fe9c314953b65833c3aa75479f2.1457029949.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Tested-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Reviewed-by: Namhyung Kim <namhyung@kernel.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2016-03-03 21:54:42 +03:00
|
|
|
|
|
|
|
#ifdef CONFIG_HIST_TRIGGERS
|
|
|
|
extern int register_trigger_hist_cmd(void);
|
2016-03-03 21:54:55 +03:00
|
|
|
extern int register_trigger_hist_enable_disable_cmds(void);
|
tracing: Add 'hist' event trigger command
'hist' triggers allow users to continually aggregate trace events,
which can then be viewed afterwards by simply reading a 'hist' file
containing the aggregation in a human-readable format.
The basic idea is very simple and boils down to a mechanism whereby
trace events, rather than being exhaustively dumped in raw form and
viewed directly, are automatically 'compressed' into meaningful tables
completely defined by the user.
This is done strictly via single-line command-line commands and
without the aid of any kind of programming language or interpreter.
A surprising number of typical use cases can be accomplished by users
via this simple mechanism. In fact, a large number of the tasks that
users typically do using the more complicated script-based tracing
tools, at least during the initial stages of an investigation, can be
accomplished by simply specifying a set of keys and values to be used
in the creation of a hash table.
The Linux kernel trace event subsystem happens to provide an extensive
list of keys and values ready-made for such a purpose in the form of
the event format files associated with each trace event. By simply
consulting the format file for field names of interest and by plugging
them into the hist trigger command, users can create an endless number
of useful aggregations to help with investigating various properties
of the system. See Documentation/trace/events.txt for examples.
hist triggers are implemented on top of the existing event trigger
infrastructure, and as such are consistent with the existing triggers
from a user's perspective as well.
The basic syntax follows the existing trigger syntax. Users start an
aggregation by writing a 'hist' trigger to the event of interest's
trigger file:
# echo hist:keys=xxx [ if filter] > event/trigger
Once a hist trigger has been set up, by default it continually
aggregates every matching event into a hash table using the event key
and a value field named 'hitcount'.
To view the aggregation at any point in time, simply read the 'hist'
file in the same directory as the 'trigger' file:
# cat event/hist
The detailed syntax provides additional options for user control, and
is described exhaustively in Documentation/trace/events.txt and in the
virtual tracing/README file in the tracing subsystem.
Link: http://lkml.kernel.org/r/72d263b5e1853fe9c314953b65833c3aa75479f2.1457029949.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Tested-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Reviewed-by: Namhyung Kim <namhyung@kernel.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2016-03-03 21:54:42 +03:00
|
|
|
#else
|
|
|
|
static inline int register_trigger_hist_cmd(void) { return 0; }
|
2016-03-03 21:54:55 +03:00
|
|
|
static inline int register_trigger_hist_enable_disable_cmds(void) { return 0; }
|
tracing: Add 'hist' event trigger command
'hist' triggers allow users to continually aggregate trace events,
which can then be viewed afterwards by simply reading a 'hist' file
containing the aggregation in a human-readable format.
The basic idea is very simple and boils down to a mechanism whereby
trace events, rather than being exhaustively dumped in raw form and
viewed directly, are automatically 'compressed' into meaningful tables
completely defined by the user.
This is done strictly via single-line command-line commands and
without the aid of any kind of programming language or interpreter.
A surprising number of typical use cases can be accomplished by users
via this simple mechanism. In fact, a large number of the tasks that
users typically do using the more complicated script-based tracing
tools, at least during the initial stages of an investigation, can be
accomplished by simply specifying a set of keys and values to be used
in the creation of a hash table.
The Linux kernel trace event subsystem happens to provide an extensive
list of keys and values ready-made for such a purpose in the form of
the event format files associated with each trace event. By simply
consulting the format file for field names of interest and by plugging
them into the hist trigger command, users can create an endless number
of useful aggregations to help with investigating various properties
of the system. See Documentation/trace/events.txt for examples.
hist triggers are implemented on top of the existing event trigger
infrastructure, and as such are consistent with the existing triggers
from a user's perspective as well.
The basic syntax follows the existing trigger syntax. Users start an
aggregation by writing a 'hist' trigger to the event of interest's
trigger file:
# echo hist:keys=xxx [ if filter] > event/trigger
Once a hist trigger has been set up, by default it continually
aggregates every matching event into a hash table using the event key
and a value field named 'hitcount'.
To view the aggregation at any point in time, simply read the 'hist'
file in the same directory as the 'trigger' file:
# cat event/hist
The detailed syntax provides additional options for user control, and
is described exhaustively in Documentation/trace/events.txt and in the
virtual tracing/README file in the tracing subsystem.
Link: http://lkml.kernel.org/r/72d263b5e1853fe9c314953b65833c3aa75479f2.1457029949.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Tested-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Reviewed-by: Namhyung Kim <namhyung@kernel.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2016-03-03 21:54:42 +03:00
|
|
|
#endif
|
tracing: Add basic event trigger framework
Add a 'trigger' file for each trace event, enabling 'trace event
triggers' to be set for trace events.
'trace event triggers' are patterned after the existing 'ftrace
function triggers' implementation except that triggers are written to
per-event 'trigger' files instead of to a single file such as the
'set_ftrace_filter' used for ftrace function triggers.
The implementation is meant to be entirely separate from ftrace
function triggers, in order to keep the respective implementations
relatively simple and to allow them to diverge.
The event trigger functionality is built on top of SOFT_DISABLE
functionality. It adds a TRIGGER_MODE bit to the ftrace_event_file
flags which is checked when any trace event fires. Triggers set for a
particular event need to be checked regardless of whether that event
is actually enabled or not - getting an event to fire even if it's not
enabled is what's already implemented by SOFT_DISABLE mode, so trigger
mode directly reuses that. Event trigger essentially inherit the soft
disable logic in __ftrace_event_enable_disable() while adding a bit of
logic and trigger reference counting via tm_ref on top of that in a
new trace_event_trigger_enable_disable() function. Because the base
__ftrace_event_enable_disable() code now needs to be invoked from
outside trace_events.c, a wrapper is also added for those usages.
The triggers for an event are actually invoked via a new function,
event_triggers_call(), and code is also added to invoke them for
ftrace_raw_event calls as well as syscall events.
The main part of the patch creates a new trace_events_trigger.c file
to contain the trace event triggers implementation.
The standard open, read, and release file operations are implemented
here.
The open() implementation sets up for the various open modes of the
'trigger' file. It creates and attaches the trigger iterator and sets
up the command parser. If opened for reading set up the trigger
seq_ops.
The read() implementation parses the event trigger written to the
'trigger' file, looks up the trigger command, and passes it along to
that event_command's func() implementation for command-specific
processing.
The release() implementation does whatever cleanup is needed to
release the 'trigger' file, like releasing the parser and trigger
iterator, etc.
A couple of functions for event command registration and
unregistration are added, along with a list to add them to and a mutex
to protect them, as well as an (initially empty) registration function
to add the set of commands that will be added by future commits, and
call to it from the trace event initialization code.
also added are a couple trigger-specific data structures needed for
these implementations such as a trigger iterator and a struct for
trigger-specific data.
A couple structs consisting mostly of function meant to be implemented
in command-specific ways, event_command and event_trigger_ops, are
used by the generic event trigger command implementations. They're
being put into trace.h alongside the other trace_event data structures
and functions, in the expectation that they'll be needed in several
trace_event-related files such as trace_events_trigger.c and
trace_events.c.
The event_command.func() function is meant to be called by the trigger
parsing code in order to add a trigger instance to the corresponding
event. It essentially coordinates adding a live trigger instance to
the event, and arming the triggering the event.
Every event_command func() implementation essentially does the
same thing for any command:
- choose ops - use the value of param to choose either a number or
count version of event_trigger_ops specific to the command
- do the register or unregister of those ops
- associate a filter, if specified, with the triggering event
The reg() and unreg() ops allow command-specific implementations for
event_trigger_op registration and unregistration, and the
get_trigger_ops() op allows command-specific event_trigger_ops
selection to be parameterized. When a trigger instance is added, the
reg() op essentially adds that trigger to the triggering event and
arms it, while unreg() does the opposite. The set_filter() function
is used to associate a filter with the trigger - if the command
doesn't specify a set_filter() implementation, the command will ignore
filters.
Each command has an associated trigger_type, which serves double duty,
both as a unique identifier for the command as well as a value that
can be used for setting a trigger mode bit during trigger invocation.
The signature of func() adds a pointer to the event_command struct,
used to invoke those functions, along with a command_data param that
can be passed to the reg/unreg functions. This allows func()
implementations to use command-specific blobs and supports code
re-use.
The event_trigger_ops.func() command corrsponds to the trigger 'probe'
function that gets called when the triggering event is actually
invoked. The other functions are used to list the trigger when
needed, along with a couple mundane book-keeping functions.
This also moves event_file_data() into trace.h so it can be used
outside of trace_events.c.
Link: http://lkml.kernel.org/r/316d95061accdee070aac8e5750afba0192fa5b9.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Idea-by: Steve Rostedt <rostedt@goodmis.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 17:59:24 +04:00
|
|
|
|
|
|
|
extern int register_trigger_cmds(void);
|
|
|
|
extern void clear_event_triggers(struct trace_array *tr);
|
|
|
|
|
|
|
|
struct event_trigger_data {
|
|
|
|
unsigned long count;
|
|
|
|
int ref;
|
|
|
|
struct event_trigger_ops *ops;
|
|
|
|
struct event_command *cmd_ops;
|
2013-12-22 06:55:17 +04: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 17:59:24 +04:00
|
|
|
char *filter_str;
|
|
|
|
void *private_data;
|
2015-12-10 21:50:47 +03:00
|
|
|
bool paused;
|
2016-03-03 21:54:58 +03:00
|
|
|
bool paused_tmp;
|
tracing: Add basic event trigger framework
Add a 'trigger' file for each trace event, enabling 'trace event
triggers' to be set for trace events.
'trace event triggers' are patterned after the existing 'ftrace
function triggers' implementation except that triggers are written to
per-event 'trigger' files instead of to a single file such as the
'set_ftrace_filter' used for ftrace function triggers.
The implementation is meant to be entirely separate from ftrace
function triggers, in order to keep the respective implementations
relatively simple and to allow them to diverge.
The event trigger functionality is built on top of SOFT_DISABLE
functionality. It adds a TRIGGER_MODE bit to the ftrace_event_file
flags which is checked when any trace event fires. Triggers set for a
particular event need to be checked regardless of whether that event
is actually enabled or not - getting an event to fire even if it's not
enabled is what's already implemented by SOFT_DISABLE mode, so trigger
mode directly reuses that. Event trigger essentially inherit the soft
disable logic in __ftrace_event_enable_disable() while adding a bit of
logic and trigger reference counting via tm_ref on top of that in a
new trace_event_trigger_enable_disable() function. Because the base
__ftrace_event_enable_disable() code now needs to be invoked from
outside trace_events.c, a wrapper is also added for those usages.
The triggers for an event are actually invoked via a new function,
event_triggers_call(), and code is also added to invoke them for
ftrace_raw_event calls as well as syscall events.
The main part of the patch creates a new trace_events_trigger.c file
to contain the trace event triggers implementation.
The standard open, read, and release file operations are implemented
here.
The open() implementation sets up for the various open modes of the
'trigger' file. It creates and attaches the trigger iterator and sets
up the command parser. If opened for reading set up the trigger
seq_ops.
The read() implementation parses the event trigger written to the
'trigger' file, looks up the trigger command, and passes it along to
that event_command's func() implementation for command-specific
processing.
The release() implementation does whatever cleanup is needed to
release the 'trigger' file, like releasing the parser and trigger
iterator, etc.
A couple of functions for event command registration and
unregistration are added, along with a list to add them to and a mutex
to protect them, as well as an (initially empty) registration function
to add the set of commands that will be added by future commits, and
call to it from the trace event initialization code.
also added are a couple trigger-specific data structures needed for
these implementations such as a trigger iterator and a struct for
trigger-specific data.
A couple structs consisting mostly of function meant to be implemented
in command-specific ways, event_command and event_trigger_ops, are
used by the generic event trigger command implementations. They're
being put into trace.h alongside the other trace_event data structures
and functions, in the expectation that they'll be needed in several
trace_event-related files such as trace_events_trigger.c and
trace_events.c.
The event_command.func() function is meant to be called by the trigger
parsing code in order to add a trigger instance to the corresponding
event. It essentially coordinates adding a live trigger instance to
the event, and arming the triggering the event.
Every event_command func() implementation essentially does the
same thing for any command:
- choose ops - use the value of param to choose either a number or
count version of event_trigger_ops specific to the command
- do the register or unregister of those ops
- associate a filter, if specified, with the triggering event
The reg() and unreg() ops allow command-specific implementations for
event_trigger_op registration and unregistration, and the
get_trigger_ops() op allows command-specific event_trigger_ops
selection to be parameterized. When a trigger instance is added, the
reg() op essentially adds that trigger to the triggering event and
arms it, while unreg() does the opposite. The set_filter() function
is used to associate a filter with the trigger - if the command
doesn't specify a set_filter() implementation, the command will ignore
filters.
Each command has an associated trigger_type, which serves double duty,
both as a unique identifier for the command as well as a value that
can be used for setting a trigger mode bit during trigger invocation.
The signature of func() adds a pointer to the event_command struct,
used to invoke those functions, along with a command_data param that
can be passed to the reg/unreg functions. This allows func()
implementations to use command-specific blobs and supports code
re-use.
The event_trigger_ops.func() command corrsponds to the trigger 'probe'
function that gets called when the triggering event is actually
invoked. The other functions are used to list the trigger when
needed, along with a couple mundane book-keeping functions.
This also moves event_file_data() into trace.h so it can be used
outside of trace_events.c.
Link: http://lkml.kernel.org/r/316d95061accdee070aac8e5750afba0192fa5b9.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Idea-by: Steve Rostedt <rostedt@goodmis.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 17:59:24 +04:00
|
|
|
struct list_head list;
|
2016-03-03 21:54:58 +03:00
|
|
|
char *name;
|
|
|
|
struct list_head named_list;
|
|
|
|
struct event_trigger_data *named_data;
|
tracing: Add basic event trigger framework
Add a 'trigger' file for each trace event, enabling 'trace event
triggers' to be set for trace events.
'trace event triggers' are patterned after the existing 'ftrace
function triggers' implementation except that triggers are written to
per-event 'trigger' files instead of to a single file such as the
'set_ftrace_filter' used for ftrace function triggers.
The implementation is meant to be entirely separate from ftrace
function triggers, in order to keep the respective implementations
relatively simple and to allow them to diverge.
The event trigger functionality is built on top of SOFT_DISABLE
functionality. It adds a TRIGGER_MODE bit to the ftrace_event_file
flags which is checked when any trace event fires. Triggers set for a
particular event need to be checked regardless of whether that event
is actually enabled or not - getting an event to fire even if it's not
enabled is what's already implemented by SOFT_DISABLE mode, so trigger
mode directly reuses that. Event trigger essentially inherit the soft
disable logic in __ftrace_event_enable_disable() while adding a bit of
logic and trigger reference counting via tm_ref on top of that in a
new trace_event_trigger_enable_disable() function. Because the base
__ftrace_event_enable_disable() code now needs to be invoked from
outside trace_events.c, a wrapper is also added for those usages.
The triggers for an event are actually invoked via a new function,
event_triggers_call(), and code is also added to invoke them for
ftrace_raw_event calls as well as syscall events.
The main part of the patch creates a new trace_events_trigger.c file
to contain the trace event triggers implementation.
The standard open, read, and release file operations are implemented
here.
The open() implementation sets up for the various open modes of the
'trigger' file. It creates and attaches the trigger iterator and sets
up the command parser. If opened for reading set up the trigger
seq_ops.
The read() implementation parses the event trigger written to the
'trigger' file, looks up the trigger command, and passes it along to
that event_command's func() implementation for command-specific
processing.
The release() implementation does whatever cleanup is needed to
release the 'trigger' file, like releasing the parser and trigger
iterator, etc.
A couple of functions for event command registration and
unregistration are added, along with a list to add them to and a mutex
to protect them, as well as an (initially empty) registration function
to add the set of commands that will be added by future commits, and
call to it from the trace event initialization code.
also added are a couple trigger-specific data structures needed for
these implementations such as a trigger iterator and a struct for
trigger-specific data.
A couple structs consisting mostly of function meant to be implemented
in command-specific ways, event_command and event_trigger_ops, are
used by the generic event trigger command implementations. They're
being put into trace.h alongside the other trace_event data structures
and functions, in the expectation that they'll be needed in several
trace_event-related files such as trace_events_trigger.c and
trace_events.c.
The event_command.func() function is meant to be called by the trigger
parsing code in order to add a trigger instance to the corresponding
event. It essentially coordinates adding a live trigger instance to
the event, and arming the triggering the event.
Every event_command func() implementation essentially does the
same thing for any command:
- choose ops - use the value of param to choose either a number or
count version of event_trigger_ops specific to the command
- do the register or unregister of those ops
- associate a filter, if specified, with the triggering event
The reg() and unreg() ops allow command-specific implementations for
event_trigger_op registration and unregistration, and the
get_trigger_ops() op allows command-specific event_trigger_ops
selection to be parameterized. When a trigger instance is added, the
reg() op essentially adds that trigger to the triggering event and
arms it, while unreg() does the opposite. The set_filter() function
is used to associate a filter with the trigger - if the command
doesn't specify a set_filter() implementation, the command will ignore
filters.
Each command has an associated trigger_type, which serves double duty,
both as a unique identifier for the command as well as a value that
can be used for setting a trigger mode bit during trigger invocation.
The signature of func() adds a pointer to the event_command struct,
used to invoke those functions, along with a command_data param that
can be passed to the reg/unreg functions. This allows func()
implementations to use command-specific blobs and supports code
re-use.
The event_trigger_ops.func() command corrsponds to the trigger 'probe'
function that gets called when the triggering event is actually
invoked. The other functions are used to list the trigger when
needed, along with a couple mundane book-keeping functions.
This also moves event_file_data() into trace.h so it can be used
outside of trace_events.c.
Link: http://lkml.kernel.org/r/316d95061accdee070aac8e5750afba0192fa5b9.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Idea-by: Steve Rostedt <rostedt@goodmis.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 17:59:24 +04:00
|
|
|
};
|
|
|
|
|
2016-03-03 21:54:55 +03:00
|
|
|
/* Avoid typos */
|
|
|
|
#define ENABLE_EVENT_STR "enable_event"
|
|
|
|
#define DISABLE_EVENT_STR "disable_event"
|
|
|
|
#define ENABLE_HIST_STR "enable_hist"
|
|
|
|
#define DISABLE_HIST_STR "disable_hist"
|
|
|
|
|
|
|
|
struct enable_trigger_data {
|
|
|
|
struct trace_event_file *file;
|
|
|
|
bool enable;
|
|
|
|
bool hist;
|
|
|
|
};
|
|
|
|
|
|
|
|
extern int event_enable_trigger_print(struct seq_file *m,
|
|
|
|
struct event_trigger_ops *ops,
|
|
|
|
struct event_trigger_data *data);
|
|
|
|
extern void event_enable_trigger_free(struct event_trigger_ops *ops,
|
|
|
|
struct event_trigger_data *data);
|
|
|
|
extern int event_enable_trigger_func(struct event_command *cmd_ops,
|
|
|
|
struct trace_event_file *file,
|
|
|
|
char *glob, char *cmd, char *param);
|
|
|
|
extern int event_enable_register_trigger(char *glob,
|
|
|
|
struct event_trigger_ops *ops,
|
|
|
|
struct event_trigger_data *data,
|
|
|
|
struct trace_event_file *file);
|
|
|
|
extern void event_enable_unregister_trigger(char *glob,
|
|
|
|
struct event_trigger_ops *ops,
|
|
|
|
struct event_trigger_data *test,
|
|
|
|
struct trace_event_file *file);
|
2015-12-10 21:50:44 +03:00
|
|
|
extern void trigger_data_free(struct event_trigger_data *data);
|
|
|
|
extern int event_trigger_init(struct event_trigger_ops *ops,
|
|
|
|
struct event_trigger_data *data);
|
|
|
|
extern int trace_event_trigger_enable_disable(struct trace_event_file *file,
|
|
|
|
int trigger_enable);
|
|
|
|
extern void update_cond_flag(struct trace_event_file *file);
|
|
|
|
extern int set_trigger_filter(char *filter_str,
|
|
|
|
struct event_trigger_data *trigger_data,
|
|
|
|
struct trace_event_file *file);
|
2016-03-03 21:54:58 +03:00
|
|
|
extern struct event_trigger_data *find_named_trigger(const char *name);
|
|
|
|
extern bool is_named_trigger(struct event_trigger_data *test);
|
|
|
|
extern int save_named_trigger(const char *name,
|
|
|
|
struct event_trigger_data *data);
|
|
|
|
extern void del_named_trigger(struct event_trigger_data *data);
|
|
|
|
extern void pause_named_trigger(struct event_trigger_data *data);
|
|
|
|
extern void unpause_named_trigger(struct event_trigger_data *data);
|
|
|
|
extern void set_named_trigger_data(struct event_trigger_data *data,
|
|
|
|
struct event_trigger_data *named_data);
|
2018-01-16 05:51:56 +03:00
|
|
|
extern struct event_trigger_data *
|
|
|
|
get_named_trigger_data(struct event_trigger_data *data);
|
2015-12-10 21:50:44 +03:00
|
|
|
extern int register_event_command(struct event_command *cmd);
|
2016-03-03 21:54:55 +03:00
|
|
|
extern int unregister_event_command(struct event_command *cmd);
|
|
|
|
extern int register_trigger_hist_enable_disable_cmds(void);
|
2015-12-10 21:50:44 +03: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 17:59:24 +04:00
|
|
|
/**
|
|
|
|
* struct event_trigger_ops - callbacks for trace event triggers
|
|
|
|
*
|
|
|
|
* The methods in this structure provide per-event trigger hooks for
|
|
|
|
* various trigger operations.
|
|
|
|
*
|
|
|
|
* All the methods below, except for @init() and @free(), must be
|
|
|
|
* implemented.
|
|
|
|
*
|
|
|
|
* @func: The trigger 'probe' function called when the triggering
|
|
|
|
* event occurs. The data passed into this callback is the data
|
|
|
|
* that was supplied to the event_command @reg() function that
|
2015-12-10 21:50:45 +03:00
|
|
|
* registered the trigger (see struct event_command) along with
|
|
|
|
* the trace record, rec.
|
tracing: Add basic event trigger framework
Add a 'trigger' file for each trace event, enabling 'trace event
triggers' to be set for trace events.
'trace event triggers' are patterned after the existing 'ftrace
function triggers' implementation except that triggers are written to
per-event 'trigger' files instead of to a single file such as the
'set_ftrace_filter' used for ftrace function triggers.
The implementation is meant to be entirely separate from ftrace
function triggers, in order to keep the respective implementations
relatively simple and to allow them to diverge.
The event trigger functionality is built on top of SOFT_DISABLE
functionality. It adds a TRIGGER_MODE bit to the ftrace_event_file
flags which is checked when any trace event fires. Triggers set for a
particular event need to be checked regardless of whether that event
is actually enabled or not - getting an event to fire even if it's not
enabled is what's already implemented by SOFT_DISABLE mode, so trigger
mode directly reuses that. Event trigger essentially inherit the soft
disable logic in __ftrace_event_enable_disable() while adding a bit of
logic and trigger reference counting via tm_ref on top of that in a
new trace_event_trigger_enable_disable() function. Because the base
__ftrace_event_enable_disable() code now needs to be invoked from
outside trace_events.c, a wrapper is also added for those usages.
The triggers for an event are actually invoked via a new function,
event_triggers_call(), and code is also added to invoke them for
ftrace_raw_event calls as well as syscall events.
The main part of the patch creates a new trace_events_trigger.c file
to contain the trace event triggers implementation.
The standard open, read, and release file operations are implemented
here.
The open() implementation sets up for the various open modes of the
'trigger' file. It creates and attaches the trigger iterator and sets
up the command parser. If opened for reading set up the trigger
seq_ops.
The read() implementation parses the event trigger written to the
'trigger' file, looks up the trigger command, and passes it along to
that event_command's func() implementation for command-specific
processing.
The release() implementation does whatever cleanup is needed to
release the 'trigger' file, like releasing the parser and trigger
iterator, etc.
A couple of functions for event command registration and
unregistration are added, along with a list to add them to and a mutex
to protect them, as well as an (initially empty) registration function
to add the set of commands that will be added by future commits, and
call to it from the trace event initialization code.
also added are a couple trigger-specific data structures needed for
these implementations such as a trigger iterator and a struct for
trigger-specific data.
A couple structs consisting mostly of function meant to be implemented
in command-specific ways, event_command and event_trigger_ops, are
used by the generic event trigger command implementations. They're
being put into trace.h alongside the other trace_event data structures
and functions, in the expectation that they'll be needed in several
trace_event-related files such as trace_events_trigger.c and
trace_events.c.
The event_command.func() function is meant to be called by the trigger
parsing code in order to add a trigger instance to the corresponding
event. It essentially coordinates adding a live trigger instance to
the event, and arming the triggering the event.
Every event_command func() implementation essentially does the
same thing for any command:
- choose ops - use the value of param to choose either a number or
count version of event_trigger_ops specific to the command
- do the register or unregister of those ops
- associate a filter, if specified, with the triggering event
The reg() and unreg() ops allow command-specific implementations for
event_trigger_op registration and unregistration, and the
get_trigger_ops() op allows command-specific event_trigger_ops
selection to be parameterized. When a trigger instance is added, the
reg() op essentially adds that trigger to the triggering event and
arms it, while unreg() does the opposite. The set_filter() function
is used to associate a filter with the trigger - if the command
doesn't specify a set_filter() implementation, the command will ignore
filters.
Each command has an associated trigger_type, which serves double duty,
both as a unique identifier for the command as well as a value that
can be used for setting a trigger mode bit during trigger invocation.
The signature of func() adds a pointer to the event_command struct,
used to invoke those functions, along with a command_data param that
can be passed to the reg/unreg functions. This allows func()
implementations to use command-specific blobs and supports code
re-use.
The event_trigger_ops.func() command corrsponds to the trigger 'probe'
function that gets called when the triggering event is actually
invoked. The other functions are used to list the trigger when
needed, along with a couple mundane book-keeping functions.
This also moves event_file_data() into trace.h so it can be used
outside of trace_events.c.
Link: http://lkml.kernel.org/r/316d95061accdee070aac8e5750afba0192fa5b9.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Idea-by: Steve Rostedt <rostedt@goodmis.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 17:59:24 +04:00
|
|
|
*
|
|
|
|
* @init: An optional initialization function called for the trigger
|
|
|
|
* when the trigger is registered (via the event_command reg()
|
|
|
|
* function). This can be used to perform per-trigger
|
|
|
|
* initialization such as incrementing a per-trigger reference
|
|
|
|
* count, for instance. This is usually implemented by the
|
|
|
|
* generic utility function @event_trigger_init() (see
|
|
|
|
* trace_event_triggers.c).
|
|
|
|
*
|
|
|
|
* @free: An optional de-initialization function called for the
|
|
|
|
* trigger when the trigger is unregistered (via the
|
|
|
|
* event_command @reg() function). This can be used to perform
|
|
|
|
* per-trigger de-initialization such as decrementing a
|
|
|
|
* per-trigger reference count and freeing corresponding trigger
|
|
|
|
* data, for instance. This is usually implemented by the
|
|
|
|
* generic utility function @event_trigger_free() (see
|
|
|
|
* trace_event_triggers.c).
|
|
|
|
*
|
|
|
|
* @print: The callback function invoked to have the trigger print
|
|
|
|
* itself. This is usually implemented by a wrapper function
|
|
|
|
* that calls the generic utility function @event_trigger_print()
|
|
|
|
* (see trace_event_triggers.c).
|
|
|
|
*/
|
|
|
|
struct event_trigger_ops {
|
2015-12-10 21:50:45 +03:00
|
|
|
void (*func)(struct event_trigger_data *data,
|
2018-01-16 05:51:42 +03:00
|
|
|
void *rec,
|
|
|
|
struct ring_buffer_event *rbe);
|
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 17:59:24 +04:00
|
|
|
int (*init)(struct event_trigger_ops *ops,
|
|
|
|
struct event_trigger_data *data);
|
|
|
|
void (*free)(struct event_trigger_ops *ops,
|
|
|
|
struct event_trigger_data *data);
|
|
|
|
int (*print)(struct seq_file *m,
|
|
|
|
struct event_trigger_ops *ops,
|
|
|
|
struct event_trigger_data *data);
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct event_command - callbacks and data members for event commands
|
|
|
|
*
|
|
|
|
* Event commands are invoked by users by writing the command name
|
|
|
|
* into the 'trigger' file associated with a trace event. The
|
|
|
|
* parameters associated with a specific invocation of an event
|
|
|
|
* command are used to create an event trigger instance, which is
|
|
|
|
* added to the list of trigger instances associated with that trace
|
|
|
|
* event. When the event is hit, the set of triggers associated with
|
|
|
|
* that event is invoked.
|
|
|
|
*
|
|
|
|
* The data members in this structure provide per-event command data
|
|
|
|
* for various event commands.
|
|
|
|
*
|
|
|
|
* All the data members below, except for @post_trigger, must be set
|
|
|
|
* for each event command.
|
|
|
|
*
|
|
|
|
* @name: The unique name that identifies the event command. This is
|
|
|
|
* the name used when setting triggers via trigger files.
|
|
|
|
*
|
|
|
|
* @trigger_type: A unique id that identifies the event command
|
|
|
|
* 'type'. This value has two purposes, the first to ensure that
|
|
|
|
* only one trigger of the same type can be set at a given time
|
|
|
|
* for a particular event e.g. it doesn't make sense to have both
|
|
|
|
* a traceon and traceoff trigger attached to a single event at
|
|
|
|
* the same time, so traceon and traceoff have the same type
|
|
|
|
* though they have different names. The @trigger_type value is
|
|
|
|
* also used as a bit value for deferring the actual trigger
|
|
|
|
* action until after the current event is finished. Some
|
|
|
|
* commands need to do this if they themselves log to the trace
|
|
|
|
* buffer (see the @post_trigger() member below). @trigger_type
|
|
|
|
* values are defined by adding new values to the trigger_type
|
2015-04-29 21:36:05 +03:00
|
|
|
* enum in include/linux/trace_events.h.
|
tracing: Add basic event trigger framework
Add a 'trigger' file for each trace event, enabling 'trace event
triggers' to be set for trace events.
'trace event triggers' are patterned after the existing 'ftrace
function triggers' implementation except that triggers are written to
per-event 'trigger' files instead of to a single file such as the
'set_ftrace_filter' used for ftrace function triggers.
The implementation is meant to be entirely separate from ftrace
function triggers, in order to keep the respective implementations
relatively simple and to allow them to diverge.
The event trigger functionality is built on top of SOFT_DISABLE
functionality. It adds a TRIGGER_MODE bit to the ftrace_event_file
flags which is checked when any trace event fires. Triggers set for a
particular event need to be checked regardless of whether that event
is actually enabled or not - getting an event to fire even if it's not
enabled is what's already implemented by SOFT_DISABLE mode, so trigger
mode directly reuses that. Event trigger essentially inherit the soft
disable logic in __ftrace_event_enable_disable() while adding a bit of
logic and trigger reference counting via tm_ref on top of that in a
new trace_event_trigger_enable_disable() function. Because the base
__ftrace_event_enable_disable() code now needs to be invoked from
outside trace_events.c, a wrapper is also added for those usages.
The triggers for an event are actually invoked via a new function,
event_triggers_call(), and code is also added to invoke them for
ftrace_raw_event calls as well as syscall events.
The main part of the patch creates a new trace_events_trigger.c file
to contain the trace event triggers implementation.
The standard open, read, and release file operations are implemented
here.
The open() implementation sets up for the various open modes of the
'trigger' file. It creates and attaches the trigger iterator and sets
up the command parser. If opened for reading set up the trigger
seq_ops.
The read() implementation parses the event trigger written to the
'trigger' file, looks up the trigger command, and passes it along to
that event_command's func() implementation for command-specific
processing.
The release() implementation does whatever cleanup is needed to
release the 'trigger' file, like releasing the parser and trigger
iterator, etc.
A couple of functions for event command registration and
unregistration are added, along with a list to add them to and a mutex
to protect them, as well as an (initially empty) registration function
to add the set of commands that will be added by future commits, and
call to it from the trace event initialization code.
also added are a couple trigger-specific data structures needed for
these implementations such as a trigger iterator and a struct for
trigger-specific data.
A couple structs consisting mostly of function meant to be implemented
in command-specific ways, event_command and event_trigger_ops, are
used by the generic event trigger command implementations. They're
being put into trace.h alongside the other trace_event data structures
and functions, in the expectation that they'll be needed in several
trace_event-related files such as trace_events_trigger.c and
trace_events.c.
The event_command.func() function is meant to be called by the trigger
parsing code in order to add a trigger instance to the corresponding
event. It essentially coordinates adding a live trigger instance to
the event, and arming the triggering the event.
Every event_command func() implementation essentially does the
same thing for any command:
- choose ops - use the value of param to choose either a number or
count version of event_trigger_ops specific to the command
- do the register or unregister of those ops
- associate a filter, if specified, with the triggering event
The reg() and unreg() ops allow command-specific implementations for
event_trigger_op registration and unregistration, and the
get_trigger_ops() op allows command-specific event_trigger_ops
selection to be parameterized. When a trigger instance is added, the
reg() op essentially adds that trigger to the triggering event and
arms it, while unreg() does the opposite. The set_filter() function
is used to associate a filter with the trigger - if the command
doesn't specify a set_filter() implementation, the command will ignore
filters.
Each command has an associated trigger_type, which serves double duty,
both as a unique identifier for the command as well as a value that
can be used for setting a trigger mode bit during trigger invocation.
The signature of func() adds a pointer to the event_command struct,
used to invoke those functions, along with a command_data param that
can be passed to the reg/unreg functions. This allows func()
implementations to use command-specific blobs and supports code
re-use.
The event_trigger_ops.func() command corrsponds to the trigger 'probe'
function that gets called when the triggering event is actually
invoked. The other functions are used to list the trigger when
needed, along with a couple mundane book-keeping functions.
This also moves event_file_data() into trace.h so it can be used
outside of trace_events.c.
Link: http://lkml.kernel.org/r/316d95061accdee070aac8e5750afba0192fa5b9.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Idea-by: Steve Rostedt <rostedt@goodmis.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 17:59:24 +04:00
|
|
|
*
|
2016-02-22 23:55:09 +03:00
|
|
|
* @flags: See the enum event_command_flags below.
|
2015-12-10 21:50:48 +03:00
|
|
|
*
|
2015-12-10 21:50:49 +03:00
|
|
|
* All the methods below, except for @set_filter() and @unreg_all(),
|
|
|
|
* must be implemented.
|
tracing: Add basic event trigger framework
Add a 'trigger' file for each trace event, enabling 'trace event
triggers' to be set for trace events.
'trace event triggers' are patterned after the existing 'ftrace
function triggers' implementation except that triggers are written to
per-event 'trigger' files instead of to a single file such as the
'set_ftrace_filter' used for ftrace function triggers.
The implementation is meant to be entirely separate from ftrace
function triggers, in order to keep the respective implementations
relatively simple and to allow them to diverge.
The event trigger functionality is built on top of SOFT_DISABLE
functionality. It adds a TRIGGER_MODE bit to the ftrace_event_file
flags which is checked when any trace event fires. Triggers set for a
particular event need to be checked regardless of whether that event
is actually enabled or not - getting an event to fire even if it's not
enabled is what's already implemented by SOFT_DISABLE mode, so trigger
mode directly reuses that. Event trigger essentially inherit the soft
disable logic in __ftrace_event_enable_disable() while adding a bit of
logic and trigger reference counting via tm_ref on top of that in a
new trace_event_trigger_enable_disable() function. Because the base
__ftrace_event_enable_disable() code now needs to be invoked from
outside trace_events.c, a wrapper is also added for those usages.
The triggers for an event are actually invoked via a new function,
event_triggers_call(), and code is also added to invoke them for
ftrace_raw_event calls as well as syscall events.
The main part of the patch creates a new trace_events_trigger.c file
to contain the trace event triggers implementation.
The standard open, read, and release file operations are implemented
here.
The open() implementation sets up for the various open modes of the
'trigger' file. It creates and attaches the trigger iterator and sets
up the command parser. If opened for reading set up the trigger
seq_ops.
The read() implementation parses the event trigger written to the
'trigger' file, looks up the trigger command, and passes it along to
that event_command's func() implementation for command-specific
processing.
The release() implementation does whatever cleanup is needed to
release the 'trigger' file, like releasing the parser and trigger
iterator, etc.
A couple of functions for event command registration and
unregistration are added, along with a list to add them to and a mutex
to protect them, as well as an (initially empty) registration function
to add the set of commands that will be added by future commits, and
call to it from the trace event initialization code.
also added are a couple trigger-specific data structures needed for
these implementations such as a trigger iterator and a struct for
trigger-specific data.
A couple structs consisting mostly of function meant to be implemented
in command-specific ways, event_command and event_trigger_ops, are
used by the generic event trigger command implementations. They're
being put into trace.h alongside the other trace_event data structures
and functions, in the expectation that they'll be needed in several
trace_event-related files such as trace_events_trigger.c and
trace_events.c.
The event_command.func() function is meant to be called by the trigger
parsing code in order to add a trigger instance to the corresponding
event. It essentially coordinates adding a live trigger instance to
the event, and arming the triggering the event.
Every event_command func() implementation essentially does the
same thing for any command:
- choose ops - use the value of param to choose either a number or
count version of event_trigger_ops specific to the command
- do the register or unregister of those ops
- associate a filter, if specified, with the triggering event
The reg() and unreg() ops allow command-specific implementations for
event_trigger_op registration and unregistration, and the
get_trigger_ops() op allows command-specific event_trigger_ops
selection to be parameterized. When a trigger instance is added, the
reg() op essentially adds that trigger to the triggering event and
arms it, while unreg() does the opposite. The set_filter() function
is used to associate a filter with the trigger - if the command
doesn't specify a set_filter() implementation, the command will ignore
filters.
Each command has an associated trigger_type, which serves double duty,
both as a unique identifier for the command as well as a value that
can be used for setting a trigger mode bit during trigger invocation.
The signature of func() adds a pointer to the event_command struct,
used to invoke those functions, along with a command_data param that
can be passed to the reg/unreg functions. This allows func()
implementations to use command-specific blobs and supports code
re-use.
The event_trigger_ops.func() command corrsponds to the trigger 'probe'
function that gets called when the triggering event is actually
invoked. The other functions are used to list the trigger when
needed, along with a couple mundane book-keeping functions.
This also moves event_file_data() into trace.h so it can be used
outside of trace_events.c.
Link: http://lkml.kernel.org/r/316d95061accdee070aac8e5750afba0192fa5b9.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Idea-by: Steve Rostedt <rostedt@goodmis.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 17:59:24 +04:00
|
|
|
*
|
|
|
|
* @func: The callback function responsible for parsing and
|
|
|
|
* registering the trigger written to the 'trigger' file by the
|
|
|
|
* user. It allocates the trigger instance and registers it with
|
|
|
|
* the appropriate trace event. It makes use of the other
|
|
|
|
* event_command callback functions to orchestrate this, and is
|
|
|
|
* usually implemented by the generic utility function
|
|
|
|
* @event_trigger_callback() (see trace_event_triggers.c).
|
|
|
|
*
|
|
|
|
* @reg: Adds the trigger to the list of triggers associated with the
|
|
|
|
* event, and enables the event trigger itself, after
|
|
|
|
* initializing it (via the event_trigger_ops @init() function).
|
|
|
|
* This is also where commands can use the @trigger_type value to
|
|
|
|
* make the decision as to whether or not multiple instances of
|
|
|
|
* the trigger should be allowed. This is usually implemented by
|
|
|
|
* the generic utility function @register_trigger() (see
|
|
|
|
* trace_event_triggers.c).
|
|
|
|
*
|
|
|
|
* @unreg: Removes the trigger from the list of triggers associated
|
|
|
|
* with the event, and disables the event trigger itself, after
|
|
|
|
* initializing it (via the event_trigger_ops @free() function).
|
|
|
|
* This is usually implemented by the generic utility function
|
|
|
|
* @unregister_trigger() (see trace_event_triggers.c).
|
|
|
|
*
|
2015-12-10 21:50:49 +03:00
|
|
|
* @unreg_all: An optional function called to remove all the triggers
|
|
|
|
* from the list of triggers associated with the event. Called
|
|
|
|
* when a trigger file is opened in truncate mode.
|
|
|
|
*
|
tracing: Add basic event trigger framework
Add a 'trigger' file for each trace event, enabling 'trace event
triggers' to be set for trace events.
'trace event triggers' are patterned after the existing 'ftrace
function triggers' implementation except that triggers are written to
per-event 'trigger' files instead of to a single file such as the
'set_ftrace_filter' used for ftrace function triggers.
The implementation is meant to be entirely separate from ftrace
function triggers, in order to keep the respective implementations
relatively simple and to allow them to diverge.
The event trigger functionality is built on top of SOFT_DISABLE
functionality. It adds a TRIGGER_MODE bit to the ftrace_event_file
flags which is checked when any trace event fires. Triggers set for a
particular event need to be checked regardless of whether that event
is actually enabled or not - getting an event to fire even if it's not
enabled is what's already implemented by SOFT_DISABLE mode, so trigger
mode directly reuses that. Event trigger essentially inherit the soft
disable logic in __ftrace_event_enable_disable() while adding a bit of
logic and trigger reference counting via tm_ref on top of that in a
new trace_event_trigger_enable_disable() function. Because the base
__ftrace_event_enable_disable() code now needs to be invoked from
outside trace_events.c, a wrapper is also added for those usages.
The triggers for an event are actually invoked via a new function,
event_triggers_call(), and code is also added to invoke them for
ftrace_raw_event calls as well as syscall events.
The main part of the patch creates a new trace_events_trigger.c file
to contain the trace event triggers implementation.
The standard open, read, and release file operations are implemented
here.
The open() implementation sets up for the various open modes of the
'trigger' file. It creates and attaches the trigger iterator and sets
up the command parser. If opened for reading set up the trigger
seq_ops.
The read() implementation parses the event trigger written to the
'trigger' file, looks up the trigger command, and passes it along to
that event_command's func() implementation for command-specific
processing.
The release() implementation does whatever cleanup is needed to
release the 'trigger' file, like releasing the parser and trigger
iterator, etc.
A couple of functions for event command registration and
unregistration are added, along with a list to add them to and a mutex
to protect them, as well as an (initially empty) registration function
to add the set of commands that will be added by future commits, and
call to it from the trace event initialization code.
also added are a couple trigger-specific data structures needed for
these implementations such as a trigger iterator and a struct for
trigger-specific data.
A couple structs consisting mostly of function meant to be implemented
in command-specific ways, event_command and event_trigger_ops, are
used by the generic event trigger command implementations. They're
being put into trace.h alongside the other trace_event data structures
and functions, in the expectation that they'll be needed in several
trace_event-related files such as trace_events_trigger.c and
trace_events.c.
The event_command.func() function is meant to be called by the trigger
parsing code in order to add a trigger instance to the corresponding
event. It essentially coordinates adding a live trigger instance to
the event, and arming the triggering the event.
Every event_command func() implementation essentially does the
same thing for any command:
- choose ops - use the value of param to choose either a number or
count version of event_trigger_ops specific to the command
- do the register or unregister of those ops
- associate a filter, if specified, with the triggering event
The reg() and unreg() ops allow command-specific implementations for
event_trigger_op registration and unregistration, and the
get_trigger_ops() op allows command-specific event_trigger_ops
selection to be parameterized. When a trigger instance is added, the
reg() op essentially adds that trigger to the triggering event and
arms it, while unreg() does the opposite. The set_filter() function
is used to associate a filter with the trigger - if the command
doesn't specify a set_filter() implementation, the command will ignore
filters.
Each command has an associated trigger_type, which serves double duty,
both as a unique identifier for the command as well as a value that
can be used for setting a trigger mode bit during trigger invocation.
The signature of func() adds a pointer to the event_command struct,
used to invoke those functions, along with a command_data param that
can be passed to the reg/unreg functions. This allows func()
implementations to use command-specific blobs and supports code
re-use.
The event_trigger_ops.func() command corrsponds to the trigger 'probe'
function that gets called when the triggering event is actually
invoked. The other functions are used to list the trigger when
needed, along with a couple mundane book-keeping functions.
This also moves event_file_data() into trace.h so it can be used
outside of trace_events.c.
Link: http://lkml.kernel.org/r/316d95061accdee070aac8e5750afba0192fa5b9.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Idea-by: Steve Rostedt <rostedt@goodmis.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 17:59:24 +04:00
|
|
|
* @set_filter: An optional function called to parse and set a filter
|
|
|
|
* for the trigger. If no @set_filter() method is set for the
|
|
|
|
* event command, filters set by the user for the command will be
|
|
|
|
* ignored. This is usually implemented by the generic utility
|
|
|
|
* function @set_trigger_filter() (see trace_event_triggers.c).
|
|
|
|
*
|
|
|
|
* @get_trigger_ops: The callback function invoked to retrieve the
|
|
|
|
* event_trigger_ops implementation associated with the command.
|
|
|
|
*/
|
|
|
|
struct event_command {
|
|
|
|
struct list_head list;
|
|
|
|
char *name;
|
|
|
|
enum event_trigger_type trigger_type;
|
2016-02-22 23:55:09 +03:00
|
|
|
int flags;
|
tracing: Add basic event trigger framework
Add a 'trigger' file for each trace event, enabling 'trace event
triggers' to be set for trace events.
'trace event triggers' are patterned after the existing 'ftrace
function triggers' implementation except that triggers are written to
per-event 'trigger' files instead of to a single file such as the
'set_ftrace_filter' used for ftrace function triggers.
The implementation is meant to be entirely separate from ftrace
function triggers, in order to keep the respective implementations
relatively simple and to allow them to diverge.
The event trigger functionality is built on top of SOFT_DISABLE
functionality. It adds a TRIGGER_MODE bit to the ftrace_event_file
flags which is checked when any trace event fires. Triggers set for a
particular event need to be checked regardless of whether that event
is actually enabled or not - getting an event to fire even if it's not
enabled is what's already implemented by SOFT_DISABLE mode, so trigger
mode directly reuses that. Event trigger essentially inherit the soft
disable logic in __ftrace_event_enable_disable() while adding a bit of
logic and trigger reference counting via tm_ref on top of that in a
new trace_event_trigger_enable_disable() function. Because the base
__ftrace_event_enable_disable() code now needs to be invoked from
outside trace_events.c, a wrapper is also added for those usages.
The triggers for an event are actually invoked via a new function,
event_triggers_call(), and code is also added to invoke them for
ftrace_raw_event calls as well as syscall events.
The main part of the patch creates a new trace_events_trigger.c file
to contain the trace event triggers implementation.
The standard open, read, and release file operations are implemented
here.
The open() implementation sets up for the various open modes of the
'trigger' file. It creates and attaches the trigger iterator and sets
up the command parser. If opened for reading set up the trigger
seq_ops.
The read() implementation parses the event trigger written to the
'trigger' file, looks up the trigger command, and passes it along to
that event_command's func() implementation for command-specific
processing.
The release() implementation does whatever cleanup is needed to
release the 'trigger' file, like releasing the parser and trigger
iterator, etc.
A couple of functions for event command registration and
unregistration are added, along with a list to add them to and a mutex
to protect them, as well as an (initially empty) registration function
to add the set of commands that will be added by future commits, and
call to it from the trace event initialization code.
also added are a couple trigger-specific data structures needed for
these implementations such as a trigger iterator and a struct for
trigger-specific data.
A couple structs consisting mostly of function meant to be implemented
in command-specific ways, event_command and event_trigger_ops, are
used by the generic event trigger command implementations. They're
being put into trace.h alongside the other trace_event data structures
and functions, in the expectation that they'll be needed in several
trace_event-related files such as trace_events_trigger.c and
trace_events.c.
The event_command.func() function is meant to be called by the trigger
parsing code in order to add a trigger instance to the corresponding
event. It essentially coordinates adding a live trigger instance to
the event, and arming the triggering the event.
Every event_command func() implementation essentially does the
same thing for any command:
- choose ops - use the value of param to choose either a number or
count version of event_trigger_ops specific to the command
- do the register or unregister of those ops
- associate a filter, if specified, with the triggering event
The reg() and unreg() ops allow command-specific implementations for
event_trigger_op registration and unregistration, and the
get_trigger_ops() op allows command-specific event_trigger_ops
selection to be parameterized. When a trigger instance is added, the
reg() op essentially adds that trigger to the triggering event and
arms it, while unreg() does the opposite. The set_filter() function
is used to associate a filter with the trigger - if the command
doesn't specify a set_filter() implementation, the command will ignore
filters.
Each command has an associated trigger_type, which serves double duty,
both as a unique identifier for the command as well as a value that
can be used for setting a trigger mode bit during trigger invocation.
The signature of func() adds a pointer to the event_command struct,
used to invoke those functions, along with a command_data param that
can be passed to the reg/unreg functions. This allows func()
implementations to use command-specific blobs and supports code
re-use.
The event_trigger_ops.func() command corrsponds to the trigger 'probe'
function that gets called when the triggering event is actually
invoked. The other functions are used to list the trigger when
needed, along with a couple mundane book-keeping functions.
This also moves event_file_data() into trace.h so it can be used
outside of trace_events.c.
Link: http://lkml.kernel.org/r/316d95061accdee070aac8e5750afba0192fa5b9.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Idea-by: Steve Rostedt <rostedt@goodmis.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 17:59:24 +04:00
|
|
|
int (*func)(struct event_command *cmd_ops,
|
2015-05-05 17:09:53 +03:00
|
|
|
struct trace_event_file *file,
|
tracing: Add basic event trigger framework
Add a 'trigger' file for each trace event, enabling 'trace event
triggers' to be set for trace events.
'trace event triggers' are patterned after the existing 'ftrace
function triggers' implementation except that triggers are written to
per-event 'trigger' files instead of to a single file such as the
'set_ftrace_filter' used for ftrace function triggers.
The implementation is meant to be entirely separate from ftrace
function triggers, in order to keep the respective implementations
relatively simple and to allow them to diverge.
The event trigger functionality is built on top of SOFT_DISABLE
functionality. It adds a TRIGGER_MODE bit to the ftrace_event_file
flags which is checked when any trace event fires. Triggers set for a
particular event need to be checked regardless of whether that event
is actually enabled or not - getting an event to fire even if it's not
enabled is what's already implemented by SOFT_DISABLE mode, so trigger
mode directly reuses that. Event trigger essentially inherit the soft
disable logic in __ftrace_event_enable_disable() while adding a bit of
logic and trigger reference counting via tm_ref on top of that in a
new trace_event_trigger_enable_disable() function. Because the base
__ftrace_event_enable_disable() code now needs to be invoked from
outside trace_events.c, a wrapper is also added for those usages.
The triggers for an event are actually invoked via a new function,
event_triggers_call(), and code is also added to invoke them for
ftrace_raw_event calls as well as syscall events.
The main part of the patch creates a new trace_events_trigger.c file
to contain the trace event triggers implementation.
The standard open, read, and release file operations are implemented
here.
The open() implementation sets up for the various open modes of the
'trigger' file. It creates and attaches the trigger iterator and sets
up the command parser. If opened for reading set up the trigger
seq_ops.
The read() implementation parses the event trigger written to the
'trigger' file, looks up the trigger command, and passes it along to
that event_command's func() implementation for command-specific
processing.
The release() implementation does whatever cleanup is needed to
release the 'trigger' file, like releasing the parser and trigger
iterator, etc.
A couple of functions for event command registration and
unregistration are added, along with a list to add them to and a mutex
to protect them, as well as an (initially empty) registration function
to add the set of commands that will be added by future commits, and
call to it from the trace event initialization code.
also added are a couple trigger-specific data structures needed for
these implementations such as a trigger iterator and a struct for
trigger-specific data.
A couple structs consisting mostly of function meant to be implemented
in command-specific ways, event_command and event_trigger_ops, are
used by the generic event trigger command implementations. They're
being put into trace.h alongside the other trace_event data structures
and functions, in the expectation that they'll be needed in several
trace_event-related files such as trace_events_trigger.c and
trace_events.c.
The event_command.func() function is meant to be called by the trigger
parsing code in order to add a trigger instance to the corresponding
event. It essentially coordinates adding a live trigger instance to
the event, and arming the triggering the event.
Every event_command func() implementation essentially does the
same thing for any command:
- choose ops - use the value of param to choose either a number or
count version of event_trigger_ops specific to the command
- do the register or unregister of those ops
- associate a filter, if specified, with the triggering event
The reg() and unreg() ops allow command-specific implementations for
event_trigger_op registration and unregistration, and the
get_trigger_ops() op allows command-specific event_trigger_ops
selection to be parameterized. When a trigger instance is added, the
reg() op essentially adds that trigger to the triggering event and
arms it, while unreg() does the opposite. The set_filter() function
is used to associate a filter with the trigger - if the command
doesn't specify a set_filter() implementation, the command will ignore
filters.
Each command has an associated trigger_type, which serves double duty,
both as a unique identifier for the command as well as a value that
can be used for setting a trigger mode bit during trigger invocation.
The signature of func() adds a pointer to the event_command struct,
used to invoke those functions, along with a command_data param that
can be passed to the reg/unreg functions. This allows func()
implementations to use command-specific blobs and supports code
re-use.
The event_trigger_ops.func() command corrsponds to the trigger 'probe'
function that gets called when the triggering event is actually
invoked. The other functions are used to list the trigger when
needed, along with a couple mundane book-keeping functions.
This also moves event_file_data() into trace.h so it can be used
outside of trace_events.c.
Link: http://lkml.kernel.org/r/316d95061accdee070aac8e5750afba0192fa5b9.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Idea-by: Steve Rostedt <rostedt@goodmis.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 17:59:24 +04:00
|
|
|
char *glob, char *cmd, char *params);
|
|
|
|
int (*reg)(char *glob,
|
|
|
|
struct event_trigger_ops *ops,
|
|
|
|
struct event_trigger_data *data,
|
2015-05-05 17:09:53 +03:00
|
|
|
struct trace_event_file *file);
|
tracing: Add basic event trigger framework
Add a 'trigger' file for each trace event, enabling 'trace event
triggers' to be set for trace events.
'trace event triggers' are patterned after the existing 'ftrace
function triggers' implementation except that triggers are written to
per-event 'trigger' files instead of to a single file such as the
'set_ftrace_filter' used for ftrace function triggers.
The implementation is meant to be entirely separate from ftrace
function triggers, in order to keep the respective implementations
relatively simple and to allow them to diverge.
The event trigger functionality is built on top of SOFT_DISABLE
functionality. It adds a TRIGGER_MODE bit to the ftrace_event_file
flags which is checked when any trace event fires. Triggers set for a
particular event need to be checked regardless of whether that event
is actually enabled or not - getting an event to fire even if it's not
enabled is what's already implemented by SOFT_DISABLE mode, so trigger
mode directly reuses that. Event trigger essentially inherit the soft
disable logic in __ftrace_event_enable_disable() while adding a bit of
logic and trigger reference counting via tm_ref on top of that in a
new trace_event_trigger_enable_disable() function. Because the base
__ftrace_event_enable_disable() code now needs to be invoked from
outside trace_events.c, a wrapper is also added for those usages.
The triggers for an event are actually invoked via a new function,
event_triggers_call(), and code is also added to invoke them for
ftrace_raw_event calls as well as syscall events.
The main part of the patch creates a new trace_events_trigger.c file
to contain the trace event triggers implementation.
The standard open, read, and release file operations are implemented
here.
The open() implementation sets up for the various open modes of the
'trigger' file. It creates and attaches the trigger iterator and sets
up the command parser. If opened for reading set up the trigger
seq_ops.
The read() implementation parses the event trigger written to the
'trigger' file, looks up the trigger command, and passes it along to
that event_command's func() implementation for command-specific
processing.
The release() implementation does whatever cleanup is needed to
release the 'trigger' file, like releasing the parser and trigger
iterator, etc.
A couple of functions for event command registration and
unregistration are added, along with a list to add them to and a mutex
to protect them, as well as an (initially empty) registration function
to add the set of commands that will be added by future commits, and
call to it from the trace event initialization code.
also added are a couple trigger-specific data structures needed for
these implementations such as a trigger iterator and a struct for
trigger-specific data.
A couple structs consisting mostly of function meant to be implemented
in command-specific ways, event_command and event_trigger_ops, are
used by the generic event trigger command implementations. They're
being put into trace.h alongside the other trace_event data structures
and functions, in the expectation that they'll be needed in several
trace_event-related files such as trace_events_trigger.c and
trace_events.c.
The event_command.func() function is meant to be called by the trigger
parsing code in order to add a trigger instance to the corresponding
event. It essentially coordinates adding a live trigger instance to
the event, and arming the triggering the event.
Every event_command func() implementation essentially does the
same thing for any command:
- choose ops - use the value of param to choose either a number or
count version of event_trigger_ops specific to the command
- do the register or unregister of those ops
- associate a filter, if specified, with the triggering event
The reg() and unreg() ops allow command-specific implementations for
event_trigger_op registration and unregistration, and the
get_trigger_ops() op allows command-specific event_trigger_ops
selection to be parameterized. When a trigger instance is added, the
reg() op essentially adds that trigger to the triggering event and
arms it, while unreg() does the opposite. The set_filter() function
is used to associate a filter with the trigger - if the command
doesn't specify a set_filter() implementation, the command will ignore
filters.
Each command has an associated trigger_type, which serves double duty,
both as a unique identifier for the command as well as a value that
can be used for setting a trigger mode bit during trigger invocation.
The signature of func() adds a pointer to the event_command struct,
used to invoke those functions, along with a command_data param that
can be passed to the reg/unreg functions. This allows func()
implementations to use command-specific blobs and supports code
re-use.
The event_trigger_ops.func() command corrsponds to the trigger 'probe'
function that gets called when the triggering event is actually
invoked. The other functions are used to list the trigger when
needed, along with a couple mundane book-keeping functions.
This also moves event_file_data() into trace.h so it can be used
outside of trace_events.c.
Link: http://lkml.kernel.org/r/316d95061accdee070aac8e5750afba0192fa5b9.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Idea-by: Steve Rostedt <rostedt@goodmis.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 17:59:24 +04:00
|
|
|
void (*unreg)(char *glob,
|
|
|
|
struct event_trigger_ops *ops,
|
|
|
|
struct event_trigger_data *data,
|
2015-05-05 17:09:53 +03:00
|
|
|
struct trace_event_file *file);
|
2015-12-10 21:50:49 +03:00
|
|
|
void (*unreg_all)(struct trace_event_file *file);
|
tracing: Add basic event trigger framework
Add a 'trigger' file for each trace event, enabling 'trace event
triggers' to be set for trace events.
'trace event triggers' are patterned after the existing 'ftrace
function triggers' implementation except that triggers are written to
per-event 'trigger' files instead of to a single file such as the
'set_ftrace_filter' used for ftrace function triggers.
The implementation is meant to be entirely separate from ftrace
function triggers, in order to keep the respective implementations
relatively simple and to allow them to diverge.
The event trigger functionality is built on top of SOFT_DISABLE
functionality. It adds a TRIGGER_MODE bit to the ftrace_event_file
flags which is checked when any trace event fires. Triggers set for a
particular event need to be checked regardless of whether that event
is actually enabled or not - getting an event to fire even if it's not
enabled is what's already implemented by SOFT_DISABLE mode, so trigger
mode directly reuses that. Event trigger essentially inherit the soft
disable logic in __ftrace_event_enable_disable() while adding a bit of
logic and trigger reference counting via tm_ref on top of that in a
new trace_event_trigger_enable_disable() function. Because the base
__ftrace_event_enable_disable() code now needs to be invoked from
outside trace_events.c, a wrapper is also added for those usages.
The triggers for an event are actually invoked via a new function,
event_triggers_call(), and code is also added to invoke them for
ftrace_raw_event calls as well as syscall events.
The main part of the patch creates a new trace_events_trigger.c file
to contain the trace event triggers implementation.
The standard open, read, and release file operations are implemented
here.
The open() implementation sets up for the various open modes of the
'trigger' file. It creates and attaches the trigger iterator and sets
up the command parser. If opened for reading set up the trigger
seq_ops.
The read() implementation parses the event trigger written to the
'trigger' file, looks up the trigger command, and passes it along to
that event_command's func() implementation for command-specific
processing.
The release() implementation does whatever cleanup is needed to
release the 'trigger' file, like releasing the parser and trigger
iterator, etc.
A couple of functions for event command registration and
unregistration are added, along with a list to add them to and a mutex
to protect them, as well as an (initially empty) registration function
to add the set of commands that will be added by future commits, and
call to it from the trace event initialization code.
also added are a couple trigger-specific data structures needed for
these implementations such as a trigger iterator and a struct for
trigger-specific data.
A couple structs consisting mostly of function meant to be implemented
in command-specific ways, event_command and event_trigger_ops, are
used by the generic event trigger command implementations. They're
being put into trace.h alongside the other trace_event data structures
and functions, in the expectation that they'll be needed in several
trace_event-related files such as trace_events_trigger.c and
trace_events.c.
The event_command.func() function is meant to be called by the trigger
parsing code in order to add a trigger instance to the corresponding
event. It essentially coordinates adding a live trigger instance to
the event, and arming the triggering the event.
Every event_command func() implementation essentially does the
same thing for any command:
- choose ops - use the value of param to choose either a number or
count version of event_trigger_ops specific to the command
- do the register or unregister of those ops
- associate a filter, if specified, with the triggering event
The reg() and unreg() ops allow command-specific implementations for
event_trigger_op registration and unregistration, and the
get_trigger_ops() op allows command-specific event_trigger_ops
selection to be parameterized. When a trigger instance is added, the
reg() op essentially adds that trigger to the triggering event and
arms it, while unreg() does the opposite. The set_filter() function
is used to associate a filter with the trigger - if the command
doesn't specify a set_filter() implementation, the command will ignore
filters.
Each command has an associated trigger_type, which serves double duty,
both as a unique identifier for the command as well as a value that
can be used for setting a trigger mode bit during trigger invocation.
The signature of func() adds a pointer to the event_command struct,
used to invoke those functions, along with a command_data param that
can be passed to the reg/unreg functions. This allows func()
implementations to use command-specific blobs and supports code
re-use.
The event_trigger_ops.func() command corrsponds to the trigger 'probe'
function that gets called when the triggering event is actually
invoked. The other functions are used to list the trigger when
needed, along with a couple mundane book-keeping functions.
This also moves event_file_data() into trace.h so it can be used
outside of trace_events.c.
Link: http://lkml.kernel.org/r/316d95061accdee070aac8e5750afba0192fa5b9.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Idea-by: Steve Rostedt <rostedt@goodmis.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 17:59:24 +04:00
|
|
|
int (*set_filter)(char *filter_str,
|
|
|
|
struct event_trigger_data *data,
|
2015-05-05 17:09:53 +03:00
|
|
|
struct trace_event_file *file);
|
tracing: Add basic event trigger framework
Add a 'trigger' file for each trace event, enabling 'trace event
triggers' to be set for trace events.
'trace event triggers' are patterned after the existing 'ftrace
function triggers' implementation except that triggers are written to
per-event 'trigger' files instead of to a single file such as the
'set_ftrace_filter' used for ftrace function triggers.
The implementation is meant to be entirely separate from ftrace
function triggers, in order to keep the respective implementations
relatively simple and to allow them to diverge.
The event trigger functionality is built on top of SOFT_DISABLE
functionality. It adds a TRIGGER_MODE bit to the ftrace_event_file
flags which is checked when any trace event fires. Triggers set for a
particular event need to be checked regardless of whether that event
is actually enabled or not - getting an event to fire even if it's not
enabled is what's already implemented by SOFT_DISABLE mode, so trigger
mode directly reuses that. Event trigger essentially inherit the soft
disable logic in __ftrace_event_enable_disable() while adding a bit of
logic and trigger reference counting via tm_ref on top of that in a
new trace_event_trigger_enable_disable() function. Because the base
__ftrace_event_enable_disable() code now needs to be invoked from
outside trace_events.c, a wrapper is also added for those usages.
The triggers for an event are actually invoked via a new function,
event_triggers_call(), and code is also added to invoke them for
ftrace_raw_event calls as well as syscall events.
The main part of the patch creates a new trace_events_trigger.c file
to contain the trace event triggers implementation.
The standard open, read, and release file operations are implemented
here.
The open() implementation sets up for the various open modes of the
'trigger' file. It creates and attaches the trigger iterator and sets
up the command parser. If opened for reading set up the trigger
seq_ops.
The read() implementation parses the event trigger written to the
'trigger' file, looks up the trigger command, and passes it along to
that event_command's func() implementation for command-specific
processing.
The release() implementation does whatever cleanup is needed to
release the 'trigger' file, like releasing the parser and trigger
iterator, etc.
A couple of functions for event command registration and
unregistration are added, along with a list to add them to and a mutex
to protect them, as well as an (initially empty) registration function
to add the set of commands that will be added by future commits, and
call to it from the trace event initialization code.
also added are a couple trigger-specific data structures needed for
these implementations such as a trigger iterator and a struct for
trigger-specific data.
A couple structs consisting mostly of function meant to be implemented
in command-specific ways, event_command and event_trigger_ops, are
used by the generic event trigger command implementations. They're
being put into trace.h alongside the other trace_event data structures
and functions, in the expectation that they'll be needed in several
trace_event-related files such as trace_events_trigger.c and
trace_events.c.
The event_command.func() function is meant to be called by the trigger
parsing code in order to add a trigger instance to the corresponding
event. It essentially coordinates adding a live trigger instance to
the event, and arming the triggering the event.
Every event_command func() implementation essentially does the
same thing for any command:
- choose ops - use the value of param to choose either a number or
count version of event_trigger_ops specific to the command
- do the register or unregister of those ops
- associate a filter, if specified, with the triggering event
The reg() and unreg() ops allow command-specific implementations for
event_trigger_op registration and unregistration, and the
get_trigger_ops() op allows command-specific event_trigger_ops
selection to be parameterized. When a trigger instance is added, the
reg() op essentially adds that trigger to the triggering event and
arms it, while unreg() does the opposite. The set_filter() function
is used to associate a filter with the trigger - if the command
doesn't specify a set_filter() implementation, the command will ignore
filters.
Each command has an associated trigger_type, which serves double duty,
both as a unique identifier for the command as well as a value that
can be used for setting a trigger mode bit during trigger invocation.
The signature of func() adds a pointer to the event_command struct,
used to invoke those functions, along with a command_data param that
can be passed to the reg/unreg functions. This allows func()
implementations to use command-specific blobs and supports code
re-use.
The event_trigger_ops.func() command corrsponds to the trigger 'probe'
function that gets called when the triggering event is actually
invoked. The other functions are used to list the trigger when
needed, along with a couple mundane book-keeping functions.
This also moves event_file_data() into trace.h so it can be used
outside of trace_events.c.
Link: http://lkml.kernel.org/r/316d95061accdee070aac8e5750afba0192fa5b9.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Idea-by: Steve Rostedt <rostedt@goodmis.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 17:59:24 +04:00
|
|
|
struct event_trigger_ops *(*get_trigger_ops)(char *cmd, char *param);
|
|
|
|
};
|
|
|
|
|
2016-02-22 23:55:09 +03:00
|
|
|
/**
|
|
|
|
* enum event_command_flags - flags for struct event_command
|
|
|
|
*
|
|
|
|
* @POST_TRIGGER: A flag that says whether or not this command needs
|
|
|
|
* to have its action delayed until after the current event has
|
|
|
|
* been closed. Some triggers need to avoid being invoked while
|
|
|
|
* an event is currently in the process of being logged, since
|
|
|
|
* the trigger may itself log data into the trace buffer. Thus
|
|
|
|
* we make sure the current event is committed before invoking
|
|
|
|
* those triggers. To do that, the trigger invocation is split
|
|
|
|
* in two - the first part checks the filter using the current
|
|
|
|
* trace record; if a command has the @post_trigger flag set, it
|
|
|
|
* sets a bit for itself in the return value, otherwise it
|
|
|
|
* directly invokes the trigger. Once all commands have been
|
|
|
|
* either invoked or set their return flag, the current record is
|
|
|
|
* either committed or discarded. At that point, if any commands
|
|
|
|
* have deferred their triggers, those commands are finally
|
|
|
|
* invoked following the close of the current event. In other
|
|
|
|
* words, if the event_trigger_ops @func() probe implementation
|
|
|
|
* itself logs to the trace buffer, this flag should be set,
|
|
|
|
* otherwise it can be left unspecified.
|
|
|
|
*
|
|
|
|
* @NEEDS_REC: A flag that says whether or not this command needs
|
|
|
|
* access to the trace record in order to perform its function,
|
|
|
|
* regardless of whether or not it has a filter associated with
|
|
|
|
* it (filters make a trigger require access to the trace record
|
|
|
|
* but are not always present).
|
|
|
|
*/
|
|
|
|
enum event_command_flags {
|
|
|
|
EVENT_CMD_FL_POST_TRIGGER = 1,
|
|
|
|
EVENT_CMD_FL_NEEDS_REC = 2,
|
|
|
|
};
|
|
|
|
|
|
|
|
static inline bool event_command_post_trigger(struct event_command *cmd_ops)
|
|
|
|
{
|
|
|
|
return cmd_ops->flags & EVENT_CMD_FL_POST_TRIGGER;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool event_command_needs_rec(struct event_command *cmd_ops)
|
|
|
|
{
|
|
|
|
return cmd_ops->flags & EVENT_CMD_FL_NEEDS_REC;
|
|
|
|
}
|
|
|
|
|
2015-05-05 17:09:53 +03:00
|
|
|
extern int trace_event_enable_disable(struct trace_event_file *file,
|
tracing: Add basic event trigger framework
Add a 'trigger' file for each trace event, enabling 'trace event
triggers' to be set for trace events.
'trace event triggers' are patterned after the existing 'ftrace
function triggers' implementation except that triggers are written to
per-event 'trigger' files instead of to a single file such as the
'set_ftrace_filter' used for ftrace function triggers.
The implementation is meant to be entirely separate from ftrace
function triggers, in order to keep the respective implementations
relatively simple and to allow them to diverge.
The event trigger functionality is built on top of SOFT_DISABLE
functionality. It adds a TRIGGER_MODE bit to the ftrace_event_file
flags which is checked when any trace event fires. Triggers set for a
particular event need to be checked regardless of whether that event
is actually enabled or not - getting an event to fire even if it's not
enabled is what's already implemented by SOFT_DISABLE mode, so trigger
mode directly reuses that. Event trigger essentially inherit the soft
disable logic in __ftrace_event_enable_disable() while adding a bit of
logic and trigger reference counting via tm_ref on top of that in a
new trace_event_trigger_enable_disable() function. Because the base
__ftrace_event_enable_disable() code now needs to be invoked from
outside trace_events.c, a wrapper is also added for those usages.
The triggers for an event are actually invoked via a new function,
event_triggers_call(), and code is also added to invoke them for
ftrace_raw_event calls as well as syscall events.
The main part of the patch creates a new trace_events_trigger.c file
to contain the trace event triggers implementation.
The standard open, read, and release file operations are implemented
here.
The open() implementation sets up for the various open modes of the
'trigger' file. It creates and attaches the trigger iterator and sets
up the command parser. If opened for reading set up the trigger
seq_ops.
The read() implementation parses the event trigger written to the
'trigger' file, looks up the trigger command, and passes it along to
that event_command's func() implementation for command-specific
processing.
The release() implementation does whatever cleanup is needed to
release the 'trigger' file, like releasing the parser and trigger
iterator, etc.
A couple of functions for event command registration and
unregistration are added, along with a list to add them to and a mutex
to protect them, as well as an (initially empty) registration function
to add the set of commands that will be added by future commits, and
call to it from the trace event initialization code.
also added are a couple trigger-specific data structures needed for
these implementations such as a trigger iterator and a struct for
trigger-specific data.
A couple structs consisting mostly of function meant to be implemented
in command-specific ways, event_command and event_trigger_ops, are
used by the generic event trigger command implementations. They're
being put into trace.h alongside the other trace_event data structures
and functions, in the expectation that they'll be needed in several
trace_event-related files such as trace_events_trigger.c and
trace_events.c.
The event_command.func() function is meant to be called by the trigger
parsing code in order to add a trigger instance to the corresponding
event. It essentially coordinates adding a live trigger instance to
the event, and arming the triggering the event.
Every event_command func() implementation essentially does the
same thing for any command:
- choose ops - use the value of param to choose either a number or
count version of event_trigger_ops specific to the command
- do the register or unregister of those ops
- associate a filter, if specified, with the triggering event
The reg() and unreg() ops allow command-specific implementations for
event_trigger_op registration and unregistration, and the
get_trigger_ops() op allows command-specific event_trigger_ops
selection to be parameterized. When a trigger instance is added, the
reg() op essentially adds that trigger to the triggering event and
arms it, while unreg() does the opposite. The set_filter() function
is used to associate a filter with the trigger - if the command
doesn't specify a set_filter() implementation, the command will ignore
filters.
Each command has an associated trigger_type, which serves double duty,
both as a unique identifier for the command as well as a value that
can be used for setting a trigger mode bit during trigger invocation.
The signature of func() adds a pointer to the event_command struct,
used to invoke those functions, along with a command_data param that
can be passed to the reg/unreg functions. This allows func()
implementations to use command-specific blobs and supports code
re-use.
The event_trigger_ops.func() command corrsponds to the trigger 'probe'
function that gets called when the triggering event is actually
invoked. The other functions are used to list the trigger when
needed, along with a couple mundane book-keeping functions.
This also moves event_file_data() into trace.h so it can be used
outside of trace_events.c.
Link: http://lkml.kernel.org/r/316d95061accdee070aac8e5750afba0192fa5b9.1382622043.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Idea-by: Steve Rostedt <rostedt@goodmis.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2013-10-24 17:59:24 +04:00
|
|
|
int enable, int soft_disable);
|
2013-10-24 17:59:26 +04:00
|
|
|
extern int tracing_alloc_snapshot(void);
|
tracing: Add conditional snapshot
Currently, tracing snapshots are context-free - they capture the ring
buffer contents at the time the tracing_snapshot() function was
invoked, and nothing else. Additionally, they're always taken
unconditionally - the calling code can decide whether or not to take a
snapshot, but the data used to make that decision is kept separately
from the snapshot itself.
This change adds the ability to associate with each trace instance
some user data, along with an 'update' function that can use that data
to determine whether or not to actually take a snapshot. The update
function can then update that data along with any other state (as part
of the data presumably), if warranted.
Because snapshots are 'global' per-instance, only one user can enable
and use a conditional snapshot for any given trace instance. To
enable a conditional snapshot (see details in the function and data
structure comments), the user calls tracing_snapshot_cond_enable().
Similarly, to disable a conditional snapshot and free it up for other
users, tracing_snapshot_cond_disable() should be called.
To actually initiate a conditional snapshot, tracing_snapshot_cond()
should be called. tracing_snapshot_cond() will invoke the update()
callback, allowing the user to decide whether or not to actually take
the snapshot and update the user-defined data associated with the
snapshot. If the callback returns 'true', tracing_snapshot_cond()
will then actually take the snapshot and return.
This scheme allows for flexibility in snapshot implementations - for
example, by implementing slightly different update() callbacks,
snapshots can be taken in situations where the user is only interested
in taking a snapshot when a new maximum in hit versus when a value
changes in any way at all. Future patches will demonstrate both
cases.
Link: http://lkml.kernel.org/r/1bea07828d5fd6864a585f83b1eed47ce097eb45.1550100284.git.tom.zanussi@linux.intel.com
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Signed-off-by: Steven Rostedt (VMware) <rostedt@goodmis.org>
2019-02-14 02:42:45 +03:00
|
|
|
extern void tracing_snapshot_cond(struct trace_array *tr, void *cond_data);
|
|
|
|
extern int tracing_snapshot_cond_enable(struct trace_array *tr, void *cond_data, cond_update_fn_t update);
|
|
|
|
|
|
|
|
extern int tracing_snapshot_cond_disable(struct trace_array *tr);
|
|
|
|
extern void *tracing_cond_snapshot_data(struct trace_array *tr);
|
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 17:59:24 +04:00
|
|
|
|
2009-03-12 21:19:25 +03:00
|
|
|
extern const char *__start___trace_bprintk_fmt[];
|
|
|
|
extern const char *__stop___trace_bprintk_fmt[];
|
|
|
|
|
2013-07-13 01:07:27 +04:00
|
|
|
extern const char *__start___tracepoint_str[];
|
|
|
|
extern const char *__stop___tracepoint_str[];
|
|
|
|
|
2015-09-30 01:21:35 +03:00
|
|
|
void trace_printk_control(bool enabled);
|
2012-10-11 18:15:05 +04:00
|
|
|
void trace_printk_start_comm(void);
|
2013-03-14 23:03:53 +04:00
|
|
|
int trace_keep_overwrite(struct tracer *tracer, u32 mask, int set);
|
2012-05-11 21:29:49 +04: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 22:01:55 +04:00
|
|
|
|
2020-01-29 12:36:44 +03:00
|
|
|
/* Used from boot time tracer */
|
|
|
|
extern int trace_set_options(struct trace_array *tr, char *option);
|
|
|
|
extern int tracing_set_tracer(struct trace_array *tr, const char *buf);
|
|
|
|
extern ssize_t tracing_resize_ring_buffer(struct trace_array *tr,
|
|
|
|
unsigned long size, int cpu_id);
|
|
|
|
extern int tracing_set_cpumask(struct trace_array *tr,
|
|
|
|
cpumask_var_t tracing_cpumask_new);
|
|
|
|
|
|
|
|
|
2017-09-22 22:58:20 +03:00
|
|
|
#define MAX_EVENT_NAME_LEN 64
|
|
|
|
|
|
|
|
extern int trace_run_command(const char *buf, int (*createfn)(int, char**));
|
|
|
|
extern ssize_t trace_parse_run_command(struct file *file,
|
|
|
|
const char __user *buffer, size_t count, loff_t *ppos,
|
|
|
|
int (*createfn)(int, char**));
|
|
|
|
|
2019-04-01 02:48:15 +03:00
|
|
|
extern unsigned int err_pos(char *cmd, const char *str);
|
2019-04-02 05:52:21 +03:00
|
|
|
extern void tracing_log_err(struct trace_array *tr,
|
|
|
|
const char *loc, const char *cmd,
|
2019-04-01 02:48:15 +03:00
|
|
|
const char **errs, u8 type, u8 pos);
|
|
|
|
|
2013-03-09 09:40:58 +04:00
|
|
|
/*
|
|
|
|
* Normal trace_printk() and friends allocates special buffers
|
|
|
|
* to do the manipulation, as well as saves the print formats
|
|
|
|
* into sections to display. But the trace infrastructure wants
|
|
|
|
* to use these without the added overhead at the price of being
|
|
|
|
* a bit slower (used mainly for warnings, where we don't care
|
|
|
|
* about performance). The internal_trace_puts() is for such
|
|
|
|
* a purpose.
|
|
|
|
*/
|
|
|
|
#define internal_trace_puts(str) __trace_puts(_THIS_IP_, str, strlen(str))
|
|
|
|
|
2009-09-13 03:26:21 +04:00
|
|
|
#undef FTRACE_ENTRY
|
2019-10-24 23:26:59 +03:00
|
|
|
#define FTRACE_ENTRY(call, struct_name, id, tstruct, print) \
|
2015-05-05 18:45:27 +03:00
|
|
|
extern struct trace_event_call \
|
2014-04-08 02:39:20 +04:00
|
|
|
__aligned(4) event_##call;
|
2009-09-13 03:26:21 +04:00
|
|
|
#undef FTRACE_ENTRY_DUP
|
2019-10-24 23:26:59 +03:00
|
|
|
#define FTRACE_ENTRY_DUP(call, struct_name, id, tstruct, print) \
|
|
|
|
FTRACE_ENTRY(call, struct_name, id, PARAMS(tstruct), PARAMS(print))
|
2016-06-29 13:56:48 +03:00
|
|
|
#undef FTRACE_ENTRY_PACKED
|
2019-10-24 23:26:59 +03:00
|
|
|
#define FTRACE_ENTRY_PACKED(call, struct_name, id, tstruct, print) \
|
|
|
|
FTRACE_ENTRY(call, struct_name, id, PARAMS(tstruct), PARAMS(print))
|
2016-06-29 13:56:48 +03:00
|
|
|
|
2009-09-13 03:26:21 +04:00
|
|
|
#include "trace_entries.h"
|
2009-03-31 09:48:49 +04:00
|
|
|
|
2012-04-13 12:52:59 +04:00
|
|
|
#if defined(CONFIG_PERF_EVENTS) && defined(CONFIG_FUNCTION_TRACER)
|
2015-05-05 18:45:27 +03:00
|
|
|
int perf_ftrace_event_register(struct trace_event_call *call,
|
2012-02-15 18:51:52 +04:00
|
|
|
enum trace_reg type, void *data);
|
|
|
|
#else
|
|
|
|
#define perf_ftrace_event_register NULL
|
2012-04-13 12:52:59 +04:00
|
|
|
#endif
|
2012-02-15 18:51:52 +04:00
|
|
|
|
2014-12-13 04:05:10 +03:00
|
|
|
#ifdef CONFIG_FTRACE_SYSCALLS
|
|
|
|
void init_ftrace_syscalls(void);
|
2015-12-10 21:50:46 +03:00
|
|
|
const char *get_syscall_name(int syscall);
|
2014-12-13 04:05:10 +03:00
|
|
|
#else
|
|
|
|
static inline void init_ftrace_syscalls(void) { }
|
2015-12-10 21:50:46 +03:00
|
|
|
static inline const char *get_syscall_name(int syscall)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
2014-12-13 04:05:10 +03:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_EVENT_TRACING
|
|
|
|
void trace_event_init(void);
|
2017-06-01 00:56:48 +03:00
|
|
|
void trace_event_eval_update(struct trace_eval_map **map, int len);
|
2020-01-29 12:36:44 +03:00
|
|
|
/* Used from boot time tracer */
|
|
|
|
extern int ftrace_set_clr_event(struct trace_array *tr, char *buf, int set);
|
|
|
|
extern int trigger_process_regex(struct trace_event_file *file, char *buff);
|
2014-12-13 04:05:10 +03:00
|
|
|
#else
|
|
|
|
static inline void __init trace_event_init(void) { }
|
2017-06-01 00:56:48 +03:00
|
|
|
static inline void trace_event_eval_update(struct trace_eval_map **map, int len) { }
|
2014-12-13 04:05:10 +03:00
|
|
|
#endif
|
|
|
|
|
2018-05-28 17:56:36 +03:00
|
|
|
#ifdef CONFIG_TRACER_SNAPSHOT
|
|
|
|
void tracing_snapshot_instance(struct trace_array *tr);
|
|
|
|
int tracing_alloc_snapshot_instance(struct trace_array *tr);
|
|
|
|
#else
|
|
|
|
static inline void tracing_snapshot_instance(struct trace_array *tr) { }
|
|
|
|
static inline int tracing_alloc_snapshot_instance(struct trace_array *tr)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2018-08-09 04:28:05 +03:00
|
|
|
#ifdef CONFIG_PREEMPT_TRACER
|
|
|
|
void tracer_preempt_on(unsigned long a0, unsigned long a1);
|
|
|
|
void tracer_preempt_off(unsigned long a0, unsigned long a1);
|
|
|
|
#else
|
|
|
|
static inline void tracer_preempt_on(unsigned long a0, unsigned long a1) { }
|
|
|
|
static inline void tracer_preempt_off(unsigned long a0, unsigned long a1) { }
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_IRQSOFF_TRACER
|
|
|
|
void tracer_hardirqs_on(unsigned long a0, unsigned long a1);
|
|
|
|
void tracer_hardirqs_off(unsigned long a0, unsigned long a1);
|
|
|
|
#else
|
|
|
|
static inline void tracer_hardirqs_on(unsigned long a0, unsigned long a1) { }
|
|
|
|
static inline void tracer_hardirqs_off(unsigned long a0, unsigned long a1) { }
|
|
|
|
#endif
|
|
|
|
|
2014-12-13 06:27:10 +03:00
|
|
|
extern struct trace_iterator *tracepoint_print_iter;
|
2014-12-13 04:05:10 +03:00
|
|
|
|
2019-05-23 15:45:35 +03:00
|
|
|
/*
|
|
|
|
* Reset the state of the trace_iterator so that it can read consumed data.
|
|
|
|
* Normally, the trace_iterator is used for reading the data when it is not
|
|
|
|
* consumed, and must retain state.
|
|
|
|
*/
|
|
|
|
static __always_inline void trace_iterator_reset(struct trace_iterator *iter)
|
|
|
|
{
|
|
|
|
const size_t offset = offsetof(struct trace_iterator, seq);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Keep gcc from complaining about overwriting more than just one
|
|
|
|
* member in the structure.
|
|
|
|
*/
|
|
|
|
memset((char *)iter + offset, 0, sizeof(struct trace_iterator) - offset);
|
|
|
|
|
|
|
|
iter->pos = -1;
|
|
|
|
}
|
|
|
|
|
2008-05-12 23:20:42 +04:00
|
|
|
#endif /* _LINUX_KERNEL_TRACE_H */
|