tracing: Updates for 5.1
Subsystems (8)
Steven Rostedt
maintainercover tracing: Updates for 5.1
git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace.git
for-next
Head SHA1: 5308e9705d9a017f0e732610ac0a7cab52fb01f7
Changbin Du (6):
function_graph: Support displaying relative timestamp
tracing: Show more info for funcgraph wakeup tracers
tracing: Put a margin between flags and duration for wakeup tracers tracing/doc: Add latency tracer funcgraph example
tracing: Show stacktrace for wakeup tracers
tracing: Change the function format to display function names by perf
Elena Reshetova (1):
uprobes: convert uprobe.ref to refcount_t
Mathieu Malaterre (2):
tracing: Annotate implicit fall through in parse_probe_arg()
tracing: Annotate implicit fall through in predicate_parse()
Miroslav Benes (1):
ring-buffer: Remove unused function ring_buffer_page_len()
Steven Rostedt (VMware) (3):
tracing: Add comment to predicate_parse() about "&&" or "||"
ftrace: Allow enabling of filters via index of available_filter_functions
tracing: Comment why cond_snapshot is checked outside of max_lock protection
Tom Zanussi (15):
tracing: Refactor hist trigger action code
tracing: Make hist trigger Documentation better reflect actions/handlers
tracing: Split up onmatch action data
tracing: Generalize hist trigger onmax and save action
tracing: Add conditional snapshot
tracing: Add hist trigger snapshot() action
tracing: Add hist trigger snapshot() action Documentation
tracing: Add hist trigger onchange() handler
tracing: Add hist trigger onchange() handler Documentation
tracing: Add alternative synthetic event trace action syntax
tracing: Add SPDX license GPL-2.0 license identifier to inter-event testcases
tracing: Add hist trigger snapshot() action test case
tracing: Add hist trigger onchange() handler test case
tracing: Add alternative synthetic event trace action test case
tracing: Add hist trigger action 'expected fail' test case
zhangyi (F) (1):
tracing: No need to free iter->trace in fail path of tracing_open_pipe()
----
Documentation/trace/ftrace.rst | 89 ++ Documentation/trace/histogram.rst | 316 +++++- include/linux/ring_buffer.h | 2 - kernel/events/uprobes.c | 8 +- kernel/trace/ftrace.c | 30 + kernel/trace/ring_buffer.c | 14 - kernel/trace/trace.c | 217 +++- kernel/trace/trace.h | 66 +- kernel/trace/trace_entries.h | 41 +- kernel/trace/trace_events_filter.c | 7 + kernel/trace/trace_events_hist.c | 1048 ++++++++++++++------ kernel/trace/trace_functions_graph.c | 30 +- kernel/trace/trace_irqsoff.c | 2 +- kernel/trace/trace_probe.c | 1 + kernel/trace/trace_sched_wakeup.c | 11 +- .../inter-event/trigger-action-hist-xfail.tc | 30 + .../inter-event/trigger-extended-error-support.tc | 1 + .../inter-event/trigger-field-variable-support.tc | 1 + .../trigger-inter-event-combined-hist.tc | 1 + .../inter-event/trigger-multi-actions-accept.tc | 1 + .../inter-event/trigger-onchange-action-hist.tc | 28 + .../inter-event/trigger-onmatch-action-hist.tc | 1 + .../trigger-onmatch-onmax-action-hist.tc | 1 + .../inter-event/trigger-onmax-action-hist.tc | 1 + .../inter-event/trigger-snapshot-action-hist.tc | 43 + .../trigger-synthetic-event-createremove.tc | 1 + .../inter-event/trigger-trace-action-hist.tc | 42 + 27 files changed, 1659 insertions(+), 374 deletions(-) create mode 100644 tools/testing/selftests/ftrace/test.d/trigger/inter-event/trigger-action-hist-xfail.tc create mode 100644 tools/testing/selftests/ftrace/test.d/trigger/inter-event/trigger-onchange-action-hist.tc create mode 100644 tools/testing/selftests/ftrace/test.d/trigger/inter-event/trigger-snapshot-action-hist.tc create mode 100644 tools/testing/selftests/ftrace/test.d/trigger/inter-event/trigger-trace-action-hist.tc
Steven Rostedt
maintainerPATCH 1/29 function_graph: Support displaying relative timestamp
From: Changbin Du <[email protected]>
When function_graph is used for latency tracers, relative timestamp is more straightforward than absolute timestamp as function trace does. This change adds relative timestamp support to function_graph and applies to latency tracers (wakeup and irqsoff).
Instead of:
# tracer: irqsoff
#
# irqsoff latency trace v1.1.5 on 5.0.0-rc1-test
# --------------------------------------------------------------------
# latency: 521 us, #1125/1125, CPU#2 | (M:preempt VP:0, KP:0, SP:0 HP:0 #P:8)
# -----------------
# | task: swapper/2-0 (uid:0 nice:0 policy:0 rt_prio:0)
# -----------------
# => started at: __schedule
# => ended at: _raw_spin_unlock_irq
#
#
# _-----=> irqs-off
# / _----=> need-resched
# | / _---=> hardirq/softirq
# || / _--=> preempt-depth
# ||| /
# TIME CPU TASK/PID |||| DURATION FUNCTION CALLS
# | | | | |||| | | | | | |
124.974306 | 2) systemd-693 | d..1 0.000 us | __schedule();
124.974307 | 2) systemd-693 | d..1 | rcu_note_context_switch() {
124.974308 | 2) systemd-693 | d..1 0.487 us | rcu_preempt_deferred_qs();
124.974309 | 2) systemd-693 | d..1 0.451 us | rcu_qs();
124.974310 | 2) systemd-693 | d..1 2.301 us | }
[..]
124.974826 | 2) <idle>-0 | d..2 | finish_task_switch() {
124.974826 | 2) <idle>-0 | d..2 | _raw_spin_unlock_irq() {
124.974827 | 2) <idle>-0 | d..2 0.000 us | _raw_spin_unlock_irq();
124.974828 | 2) <idle>-0 | d..2 0.000 us | tracer_hardirqs_on();
<idle>-0 2d..2 552us : <stack trace>
=> __schedule
=> schedule_idle
=> do_idle
=> cpu_startup_entry
=> start_secondary
=> secondary_startup_64Show:
# tracer: irqsoff
#
# irqsoff latency trace v1.1.5 on 5.0.0-rc1-test+
# --------------------------------------------------------------------
# latency: 511 us, #1053/1053, CPU#7 | (M:preempt VP:0, KP:0, SP:0 HP:0 #P:8)
# -----------------
# | task: swapper/7-0 (uid:0 nice:0 policy:0 rt_prio:0)
# -----------------
# => started at: __schedule
# => ended at: _raw_spin_unlock_irq
#
#
# _-----=> irqs-off
# / _----=> need-resched
# | / _---=> hardirq/softirq
# || / _--=> preempt-depth
# ||| /
# REL TIME CPU TASK/PID |||| DURATION FUNCTION CALLS
# | | | | |||| | | | | | |
0 us | 7) sshd-1704 | d..1 0.000 us | __schedule();
1 us | 7) sshd-1704 | d..1 | rcu_note_context_switch() {
1 us | 7) sshd-1704 | d..1 0.611 us | rcu_preempt_deferred_qs();
2 us | 7) sshd-1704 | d..1 0.484 us | rcu_qs();
3 us | 7) sshd-1704 | d..1 2.599 us | }
[..]
509 us | 7) <idle>-0 | d..2 | finish_task_switch() {
510 us | 7) <idle>-0 | d..2 | _raw_spin_unlock_irq() {
510 us | 7) <idle>-0 | d..2 0.000 us | _raw_spin_unlock_irq();
512 us | 7) <idle>-0 | d..2 0.000 us | tracer_hardirqs_on();
<idle>-0 7d..2 543us : <stack trace>
=> __schedule
=> schedule_idle
=> do_idle
=> cpu_startup_entry
=> start_secondary
=> secondary_startup_64--- kernel/trace/trace.h | 9 +++++---- kernel/trace/trace_functions_graph.c | 25 +++++++++++++++++++++++++ kernel/trace/trace_irqsoff.c | 2 +- kernel/trace/trace_sched_wakeup.c | 2 +- 4 files changed, 32 insertions(+), 6 deletions(-)
kernel/trace/trace.h +5 -4
@@ -855,10 +855,11 @@ static __always_inline bool ftrace_hash_empty(struct ftrace_hash *hash)#define TRACE_GRAPH_PRINT_PROC 0x8#define TRACE_GRAPH_PRINT_DURATION 0x10#define TRACE_GRAPH_PRINT_ABS_TIME 0x20 -#define TRACE_GRAPH_PRINT_IRQS 0x40 -#define TRACE_GRAPH_PRINT_TAIL 0x80 -#define TRACE_GRAPH_SLEEP_TIME 0x100 -#define TRACE_GRAPH_GRAPH_TIME 0x200 +#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#define TRACE_GRAPH_PRINT_FILL_SHIFT 28#define TRACE_GRAPH_PRINT_FILL_MASK (0x3 << TRACE_GRAPH_PRINT_FILL_SHIFT)
kernel/trace/trace_functions_graph.c +25 -0
@@ -500,6 +500,17 @@ static void print_graph_abs_time(u64 t, struct trace_seq *s) (unsigned long)t, usecs_rem); } +static void +print_graph_rel_time (struct trace_iterator *iter,struct trace_seq *s) +{ +unsigned long long usecs; + + usecs = iter->ts - iter->trace_buffer->time_start; +do_div (usecs,NSEC_PER_USEC ); + +trace_seq_printf (s,"%9llu us | " , usecs); +} +static void print_graph_irq (struct trace_iterator *iter,unsigned long addr,enum trace_type type,int cpu,pid_t pid,u32 flags)
@@ -517,6 +528,10 @@ print_graph_irq(struct trace_iterator *iter, unsigned long addr,if (flags &TRACE_GRAPH_PRINT_ABS_TIME )print_graph_abs_time (iter->ts, s); +/* Relative time */ +if (flags &TRACE_GRAPH_PRINT_REL_TIME ) +print_graph_rel_time (iter, s); +/* Cpu */ if (flags &TRACE_GRAPH_PRINT_CPU )print_graph_cpu (s, cpu);
@@ -725,6 +740,10 @@ print_graph_prologue(struct trace_iterator *iter, struct trace_seq *s,if (flags &TRACE_GRAPH_PRINT_ABS_TIME )print_graph_abs_time (iter->ts, s); +/* Relative time */ +if (flags &TRACE_GRAPH_PRINT_REL_TIME ) +print_graph_rel_time (iter, s); +/* Cpu */ if (flags &TRACE_GRAPH_PRINT_CPU )print_graph_cpu (s, cpu);
@@ -1101,6 +1120,8 @@ static void print_lat_header(struct seq_file *s, u32 flags)if (flags &TRACE_GRAPH_PRINT_ABS_TIME ) size +=16 ; +if (flags &TRACE_GRAPH_PRINT_REL_TIME ) + size +=16 ;if (flags &TRACE_GRAPH_PRINT_CPU ) size +=4 ;if (flags &TRACE_GRAPH_PRINT_PROC )
@@ -1125,6 +1146,8 @@ static void __print_graph_headers_flags(struct trace_array *tr,seq_putc (s,'#' );if (flags &TRACE_GRAPH_PRINT_ABS_TIME )seq_puts (s," TIME " ); +if (flags &TRACE_GRAPH_PRINT_REL_TIME ) +seq_puts (s," REL TIME " );if (flags &TRACE_GRAPH_PRINT_CPU )seq_puts (s," CPU" );if (flags &TRACE_GRAPH_PRINT_PROC )
@@ -1139,6 +1162,8 @@ static void __print_graph_headers_flags(struct trace_array *tr,seq_putc (s,'#' );if (flags &TRACE_GRAPH_PRINT_ABS_TIME )seq_puts (s," | " ); +if (flags &TRACE_GRAPH_PRINT_REL_TIME ) +seq_puts (s," | " );if (flags &TRACE_GRAPH_PRINT_CPU )seq_puts (s," | " );if (flags &TRACE_GRAPH_PRINT_PROC )
kernel/trace/trace_irqsoff.c +1 -1
@@ -238,7 +238,7 @@ static void irqsoff_trace_close(struct trace_iterator *iter)#define GRAPH_TRACER_FLAGS (TRACE_GRAPH_PRINT_CPU | \ TRACE_GRAPH_PRINT_PROC | \ - TRACE_GRAPH_PRINT_ABS_TIME | \ + TRACE_GRAPH_PRINT_REL_TIME | \ TRACE_GRAPH_PRINT_DURATION)static enum print_line_t irqsoff_print_line (struct trace_iterator *iter)
kernel/trace/trace_sched_wakeup.c +1 -1
@@ -180,7 +180,7 @@ static void wakeup_trace_close(struct trace_iterator *iter) }#define GRAPH_TRACER_FLAGS (TRACE_GRAPH_PRINT_PROC | \ - TRACE_GRAPH_PRINT_ABS_TIME | \ + TRACE_GRAPH_PRINT_REL_TIME | \ TRACE_GRAPH_PRINT_DURATION)static enum print_line_t wakeup_print_line (struct trace_iterator *iter)
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 2/29 tracing: Annotate implicit fall through in parse_probe_arg()
In reply to Steven RostedtFrom: Mathieu Malaterre <[email protected]>
There is a plan to build the kernel with -Wimplicit-fallthrough and this place in the code produced a warning (W=1).
This commit remove the following warning:
kernel/trace/trace_probe.c:302:6: warning: this statement may fall through [-Wimplicit-fallthrough=]
--- kernel/trace/trace_probe.c | 1 + 1 file changed, 1 insertion(+)
kernel/trace/trace_probe.c +1 -0
@@ -300,6 +300,7 @@ parse_probe_arg(char *arg, const struct fetch_type *type,case '+' :/* deref memory */ arg++;/* Skip '+', because kstrtol() rejects it. */ +/* fall through */ case '-' : tmp =strchr (arg,'(' );if (!tmp)
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 3/29 tracing: Annotate implicit fall through in predicate_parse()
In reply to Steven RostedtFrom: Mathieu Malaterre <[email protected]>
There is a plan to build the kernel with -Wimplicit-fallthrough and this place in the code produced a warning (W=1).
This commit remove the following warning:
kernel/trace/trace_events_filter.c:494:8: warning: this statement may fall through [-Wimplicit-fallthrough=]
--- kernel/trace/trace_events_filter.c | 1 + 1 file changed, 1 insertion(+)
kernel/trace/trace_events_filter.c +1 -0
@@ -495,6 +495,7 @@ predicate_parse(const char *str, int nr_parens, int nr_preds, ptr++;break ; } +/* fall through */ default :parse_error (pe,FILT_ERR_TOO_MANY_PREDS , next - str);
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 4/29 tracing: Add comment to predicate_parse() about "&&" or "||"
In reply to Steven RostedtFrom: "Steven Rostedt (VMware)" <[email protected]>
As the predicat_parse() code is rather complex, commenting subtleties is important. The switch case statement should be commented to describe that it is only looking for two '&' or '|' together, which is why the fall through to an error is after the check.
--- kernel/trace/trace_events_filter.c | 1 + 1 file changed, 1 insertion(+)
kernel/trace/trace_events_filter.c +1 -0
@@ -491,6 +491,7 @@ predicate_parse(const char *str, int nr_parens, int nr_preds,break ;case '&' :case '|' : +/* accepting only "&&" or "||" */ if (next[1 ] == next[0 ]) { ptr++;break ;
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 5/29 tracing: Show more info for funcgraph wakeup tracers
In reply to Steven RostedtFrom: Changbin Du <[email protected]>
Add these info fields to funcgraph wakeup tracers:
o Show CPU info since the waker could be on a different CPU.
o Show function duration and overhead.
o Show IRQ markers.
--- kernel/trace/trace_sched_wakeup.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
kernel/trace/trace_sched_wakeup.c +4 -1
@@ -180,8 +180,11 @@ static void wakeup_trace_close(struct trace_iterator *iter) }#define GRAPH_TRACER_FLAGS (TRACE_GRAPH_PRINT_PROC | \ + TRACE_GRAPH_PRINT_CPU | \ TRACE_GRAPH_PRINT_REL_TIME | \ - TRACE_GRAPH_PRINT_DURATION) + TRACE_GRAPH_PRINT_DURATION | \ + TRACE_GRAPH_PRINT_OVERHEAD | \ + TRACE_GRAPH_PRINT_IRQS)static enum print_line_t wakeup_print_line (struct trace_iterator *iter) {
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 6/29 tracing: Put a margin between flags and duration for wakeup tracers
In reply to Steven RostedtFrom: Changbin Du <[email protected]>
Don't mix context flags with function duration info.
Instead of this:
# tracer: wakeup_rt
#
# wakeup_rt latency trace v1.1.5 on 5.0.0-rc1-test+
# --------------------------------------------------------------------
# latency: 177 us, #545/545, CPU#0 | (M:preempt VP:0, KP:0, SP:0 HP:0 #P:8)
# -----------------
# | task: migration/0-11 (uid:0 nice:0 policy:1 rt_prio:99)
# -----------------
#
# _-----=> irqs-off
# / _----=> need-resched
# | / _---=> hardirq/softirq
# || / _--=> preempt-depth
# ||| /
# REL TIME CPU TASK/PID |||| DURATION FUNCTION CALLS
# | | | | |||| | | | | | |
0 us | 0) <idle>-0 | dNh5 | /* 0:120:R + [000] 11: 0:R migration/0 */
2 us | 0) <idle>-0 | dNh5 0.000 us | (null)();
4 us | 0) <idle>-0 | dNh4 | _raw_spin_unlock() {
4 us | 0) <idle>-0 | dNh4 0.304 us | preempt_count_sub();
5 us | 0) <idle>-0 | dNh3 1.063 us | }
5 us | 0) <idle>-0 | dNh3 0.266 us | ttwu_stat();
6 us | 0) <idle>-0 | dNh3 | _raw_spin_unlock_irqrestore() {
6 us | 0) <idle>-0 | dNh3 0.273 us | preempt_count_sub();
6 us | 0) <idle>-0 | dNh2 0.818 us | }Show this:
# tracer: wakeup
#
# wakeup latency trace v1.1.5 on 4.20.0+
# --------------------------------------------------------------------
# latency: 593 us, #674/674, CPU#0 | (M:desktop VP:0, KP:0, SP:0 HP:0 #P:4)
# -----------------
# | task: kworker/0:1H-339 (uid:0 nice:-20 policy:0 rt_prio:0)
# -----------------
#
# _-----=> irqs-off
# / _----=> need-resched
# | / _---=> hardirq/softirq
# || / _--=> preempt-depth
# ||| /
# REL TIME CPU TASK/PID |||| DURATION FUNCTION CALLS
# | | | | |||| | | | | | |
0 us | 0) <idle>-0 | dNs. | | /* 0:120:R + [000] 339:100:R kworker/0:1H */
3 us | 0) <idle>-0 | dNs. | 0.000 us | (null)();
67 us | 0) <idle>-0 | dNs. | 0.721 us | ttwu_stat();
69 us | 0) <idle>-0 | dNs. | 0.607 us | _raw_spin_unlock_irqrestore();
71 us | 0) <idle>-0 | .Ns. | 0.598 us | _raw_spin_lock_irq();
72 us | 0) <idle>-0 | .Ns. | 0.584 us | _raw_spin_lock_irq();
73 us | 0) <idle>-0 | dNs. | + 11.118 us | __next_timer_interrupt();
75 us | 0) <idle>-0 | dNs. | | call_timer_fn() {
76 us | 0) <idle>-0 | dNs. | | delayed_work_timer_fn() {
76 us | 0) <idle>-0 | dNs. | | __queue_work() {
...--- kernel/trace/trace_functions_graph.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
kernel/trace/trace_functions_graph.c +3 -2
@@ -380,6 +380,7 @@ static void print_graph_lat_fmt(struct trace_seq *s, struct trace_entry *entry) {trace_seq_putc (s,' ' );trace_print_lat_fmt (s, entry); +trace_seq_puts (s," | " ); }/* If the pid changed since the last trace, output this event */
@@ -1153,7 +1154,7 @@ static void __print_graph_headers_flags(struct trace_array *tr,if (flags &TRACE_GRAPH_PRINT_PROC )seq_puts (s," TASK/PID " );if (lat) -seq_puts (s,"||||" ); +seq_puts (s,"|||| " );if (flags &TRACE_GRAPH_PRINT_DURATION )seq_puts (s," DURATION " );seq_puts (s," FUNCTION CALLS\n" );
@@ -1169,7 +1170,7 @@ static void __print_graph_headers_flags(struct trace_array *tr,if (flags &TRACE_GRAPH_PRINT_PROC )seq_puts (s," | | " );if (lat) -seq_puts (s,"||||" ); +seq_puts (s,"|||| " );if (flags &TRACE_GRAPH_PRINT_DURATION )seq_puts (s," | | " );seq_puts (s," | | | |\n" );
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 7/29 tracing/doc: Add latency tracer funcgraph example
In reply to Steven RostedtFrom: Changbin Du <[email protected]>
This add an example about how to use funcgraph with latency tracers.
--- Documentation/trace/ftrace.rst | 51 ++++++++++++++++++++++++++++++++++ 1 file changed, 51 insertions(+)
Documentation/trace/ftrace.rst +51 -0
@@ -1396,6 +1396,57 @@ enabling function tracing, we incur an added overhead. This overhead may extend the latency times. But nevertheless, this trace has provided some very helpful debugging information. +If we prefer function graph output instead of function, we can set +display-graph option:: + with echo 1 > options/display-graph + + # tracer: irqsoff + # + # irqsoff latency trace v1.1.5 on 4.20.0-rc6+ + # -------------------------------------------------------------------- + # latency: 3751 us, #274/274, CPU#0 | (M:desktop VP:0, KP:0, SP:0 HP:0 #P:4) + # ----------------- + # | task: bash-1507 (uid:0 nice:0 policy:0 rt_prio:0) + # ----------------- + # => started at: free_debug_processing + # => ended at: return_to_handler + # + # + # _-----=> irqs-off + # / _----=> need-resched + # | / _---=> hardirq/softirq + # || / _--=> preempt-depth + # ||| / + # REL TIME CPU TASK/PID |||| DURATION FUNCTION CALLS + # | | | | |||| | | | | | | + 0 us | 0) bash-1507 | d... | 0.000 us | _raw_spin_lock_irqsave(); + 0 us | 0) bash-1507 | d..1 | 0.378 us | do_raw_spin_trylock(); + 1 us | 0) bash-1507 | d..2 | | set_track() { + 2 us | 0) bash-1507 | d..2 | | save_stack_trace() { + 2 us | 0) bash-1507 | d..2 | | __save_stack_trace() { + 3 us | 0) bash-1507 | d..2 | | __unwind_start() { + 3 us | 0) bash-1507 | d..2 | | get_stack_info() { + 3 us | 0) bash-1507 | d..2 | 0.351 us | in_task_stack(); + 4 us | 0) bash-1507 | d..2 | 1.107 us | } + [...] + 3750 us | 0) bash-1507 | d..1 | 0.516 us | do_raw_spin_unlock(); + 3750 us | 0) bash-1507 | d..1 | 0.000 us | _raw_spin_unlock_irqrestore(); + 3764 us | 0) bash-1507 | d..1 | 0.000 us | tracer_hardirqs_on(); + bash-1507 0d..1 3792us : <stack trace> + => free_debug_processing + => __slab_free + => kmem_cache_free + => vm_area_free + => remove_vma + => exit_mmap + => mmput + => flush_old_exec + => load_elf_binary + => search_binary_handler + => __do_execve_file.isra.32 + => __x64_sys_execve + => do_syscall_64 + => entry_SYSCALL_64_after_hwframe preemptoff ----------
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 8/29 tracing: Show stacktrace for wakeup tracers
In reply to Steven RostedtFrom: Changbin Du <[email protected]>
This align the behavior of wakeup tracers with irqsoff latency tracer that we record stacktrace at the beginning and end of waking up. The stacktrace shows us what is happening in the kernel.
--- kernel/trace/trace_sched_wakeup.c | 2 ++ 1 file changed, 2 insertions(+)
kernel/trace/trace_sched_wakeup.c +2 -0
@@ -475,6 +475,7 @@ probe_wakeup_sched_switch(void *ignore, bool preempt,__trace_function (wakeup_trace,CALLER_ADDR0 ,CALLER_ADDR1 , flags, pc);tracing_sched_switch_trace (wakeup_trace, prev, next, flags, pc); +__trace_stack (wakeup_trace, flags,0 , pc);T0 = data->preempt_timestamp;T1 =ftrace_now (cpu);
@@ -586,6 +587,7 @@ probe_wakeup(void *ignore, struct task_struct *p) data =per_cpu_ptr (wakeup_trace->trace_buffer.data, wakeup_cpu); data->preempt_timestamp =ftrace_now (cpu);tracing_sched_wakeup_trace (wakeup_trace, p, current, flags, pc); +__trace_stack (wakeup_trace, flags,0 , pc);/* * We must be careful in using CALLER_ADDR2. But since wake_up
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 9/29 ring-buffer: Remove unused function ring_buffer_page_len()
In reply to Steven RostedtFrom: Miroslav Benes <[email protected]>
Commit 6b7e633fe9c2 ("tracing: Remove extra zeroing out of the ring buffer page") removed the only caller of ring_buffer_page_len(). The function is now unused and may be removed.
--- include/linux/ring_buffer.h | 2 -- kernel/trace/ring_buffer.c | 14 -------------- 2 files changed, 16 deletions(-)
include/linux/ring_buffer.h +0 -2
@@ -187,8 +187,6 @@ void ring_buffer_set_clock(struct ring_buffer *buffer,void ring_buffer_set_time_stamp_abs (struct ring_buffer *buffer,bool abs);bool ring_buffer_time_stamp_abs (struct ring_buffer *buffer); -size_t ring_buffer_page_len (void *page); -size_t ring_buffer_nr_pages (struct ring_buffer *buffer,int cpu);size_t ring_buffer_nr_dirty_pages (struct ring_buffer *buffer,int cpu);
kernel/trace/ring_buffer.c +0 -14
@@ -353,20 +353,6 @@ static void rb_init_page(struct buffer_data_page *bpage)local_set (&bpage->commit,0 ); } -/** -* ring_buffer_page_len - the size of data on the page. -* @page: The page to read -* -* Returns the amount of data on the page, including buffer page header. -*/ -size_t ring_buffer_page_len (void *page) -{ -struct buffer_data_page *bpage = page; - -return (local_read (&bpage->commit) & ~RB_MISSED_FLAGS ) - +BUF_PAGE_HDR_SIZE ; -} -/* * Also stolen from mm/slob.c. Thanks to Mathieu Desnoyers for pointing * this issue out.
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 10/29 tracing: Change the function format to display function names by perf
In reply to Steven RostedtFrom: Changbin Du <[email protected]>
Here is an example for this change.
$ sudo perf record -e 'ftrace:function' --filter='ip==schedule' $ sudo perf report
The output of perf before this patch:
\# Samples: 100 of event 'ftrace:function' \# Event count (approx.): 100
\#
\# Overhead Trace output
\# ........ ...................................... \#
51.00% ffffffff81f6aaa0 <-- ffffffff81158e8d
29.00% ffffffff81f6aaa0 <-- ffffffff8116ccb2
8.00% ffffffff81f6aaa0 <-- ffffffff81f6f2ed
4.00% ffffffff81f6aaa0 <-- ffffffff811628db
4.00% ffffffff81f6aaa0 <-- ffffffff81f6ec5b
2.00% ffffffff81f6aaa0 <-- ffffffff81f6f21a
1.00% ffffffff81f6aaa0 <-- ffffffff811b04af
1.00% ffffffff81f6aaa0 <-- ffffffff8143ce17After this patch:
\# Samples: 36 of event 'ftrace:function'
\# Event count (approx.): 36
\#
\# Overhead Trace output
\# ........ ............................................ \#
38.89% schedule <-- schedule_hrtimeout_range_clock
27.78% schedule <-- worker_thread
13.89% schedule <-- schedule_timeout
11.11% schedule <-- smpboot_thread_fn
5.56% schedule <-- rcu_gp_kthread
2.78% schedule <-- exit_to_usermode_loop--- kernel/trace/trace_entries.h | 41 +++++++++++++++++------------------- 1 file changed, 19 insertions(+), 22 deletions(-)
kernel/trace/trace_entries.h +19 -22
@@ -65,7 +65,8 @@ FTRACE_ENTRY_REG(function, ftrace_entry, __field( unsigned long, parent_ip ) ), - F_printk(" %lx <-- %lx", __entry->ip, __entry->parent_ip), + F_printk(" %ps <-- %ps", + (void *)__entry->ip, (void *)__entry->parent_ip), FILTER_TRACE_FN,
@@ -83,7 +84,7 @@ FTRACE_ENTRY_PACKED(funcgraph_entry, ftrace_graph_ent_entry,__field_desc ( int, graph_ent, depth ) ), -F_printk ("--> %lx (%d)" , __entry->func, __entry->depth), +F_printk ("--> %ps (%d)" , (void *)__entry->func, __entry->depth),FILTER_OTHER );
@@ -102,8 +103,8 @@ FTRACE_ENTRY_PACKED(funcgraph_exit, ftrace_graph_ret_entry,__field_desc ( int, ret, depth ) ), -F_printk ("<-- %lx (%d) (start: %llx end: %llx) over: %d" , - __entry->func, __entry->depth, +F_printk ("<-- %ps (%d) (start: %llx end: %llx) over: %d" , + (void *)__entry->func, __entry->depth, __entry->calltime, __entry->rettime, __entry->depth),
@@ -167,12 +168,6 @@ FTRACE_ENTRY_DUP(wakeup, ctx_switch_entry,#define FTRACE_STACK_ENTRIES 8 -#ifndef CONFIG_64BIT -# define IP_FMT "%08lx" -#else -# define IP_FMT "%016lx" -#endif - FTRACE_ENTRY(kernel_stack, stack_entry, TRACE_STACK,
@@ -182,12 +177,13 @@ FTRACE_ENTRY(kernel_stack, stack_entry, __dynamic_array(unsigned long, caller ) ), - F_printk("\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n" - "\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n" - "\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n", - __entry->caller[0], __entry->caller[1], __entry->caller[2], - __entry->caller[3], __entry->caller[4], __entry->caller[5], - __entry->caller[6], __entry->caller[7]), + F_printk("\t=> %ps\n\t=> %ps\n\t=> %ps\n" + "\t=> %ps\n\t=> %ps\n\t=> %ps\n" + "\t=> %ps\n\t=> %ps\n", + (void *)__entry->caller[0], (void *)__entry->caller[1], + (void *)__entry->caller[2], (void *)__entry->caller[3], + (void *)__entry->caller[4], (void *)__entry->caller[5], + (void *)__entry->caller[6], (void *)__entry->caller[7]),FILTER_OTHER );
@@ -201,12 +197,13 @@ FTRACE_ENTRY(user_stack, userstack_entry, __array( unsigned long, caller, FTRACE_STACK_ENTRIES ) ), -F_printk ("\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n" -"\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n" -"\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n" , - __entry->caller[0 ], __entry->caller[1 ], __entry->caller[2 ], - __entry->caller[3 ], __entry->caller[4 ], __entry->caller[5 ], - __entry->caller[6 ], __entry->caller[7 ]), +F_printk ("\t=> %ps\n\t=> %ps\n\t=> %ps\n" +"\t=> %ps\n\t=> %ps\n\t=> %ps\n" +"\t=> %ps\n\t=> %ps\n" , + (void *)__entry->caller[0 ], (void *)__entry->caller[1 ], + (void *)__entry->caller[2 ], (void *)__entry->caller[3 ], + (void *)__entry->caller[4 ], (void *)__entry->caller[5 ], + (void *)__entry->caller[6 ], (void *)__entry->caller[7 ]),FILTER_OTHER );
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 11/29 ftrace: Allow enabling of filters via index of available_filter_functions
In reply to Steven RostedtFrom: "Steven Rostedt (VMware)" <[email protected]>
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
--- Documentation/trace/ftrace.rst | 38 ++++++++++++++++++++++++++++++ kernel/trace/ftrace.c | 30 +++++++++++++++++++++++ kernel/trace/trace.h | 1 + kernel/trace/trace_events_filter.c | 5 ++++ 4 files changed, 74 insertions(+)
Documentation/trace/ftrace.rst +38 -0
@@ -233,6 +233,12 @@ of ftrace. Here is a list of some of the key files: This interface also allows for commands to be used. See the "Filter commands" section for more details. + As a speed up, since processing strings can't be quite expensive + and requires a check of all functions registered to tracing, instead + an index can be written into this file. A number (starting with "1") + written will instead select the same corresponding at the line position + of the "available_filter_functions" file. + set_ftrace_notrace: This has an effect opposite to that of
@@ -2835,6 +2841,38 @@ Produces:: We can see that there's no more lock or preempt tracing. +Selecting function filters via index +------------------------------------ + +Because processing of strings is expensive (the address of the function +needs to be looked up before comparing to the string being passed in), +an index can be used as well to enable functions. This is useful in the +case of setting thousands of specific functions at a time. By passing +in a list of numbers, no string processing will occur. Instead, the function +at the specific location in the internal array (which corresponds to the +functions in the "available_filter_functions" file), is selected. + +:: + + # echo 1 > set_ftrace_filter + +Will select the first function listed in "available_filter_functions" + +:: + + # head -1 available_filter_functions + trace_initcall_finish_cb + + # cat set_ftrace_filter + trace_initcall_finish_cb + + # head -50 available_filter_functions | tail -1 + x86_pmu_commit_txn + + # echo 1 50 > set_ftrace_filter + # cat set_ftrace_filter + trace_initcall_finish_cb + x86_pmu_commit_txn Dynamic ftrace with the function graph tracer ---------------------------------------------
kernel/trace/ftrace.c +30 -0
@@ -3701,6 +3701,31 @@ enter_record(struct ftrace_hash *hash, struct dyn_ftrace *rec, int clear_filter)return ret; } +static int +add_rec_by_index (struct ftrace_hash *hash,struct ftrace_glob *func_g, +int clear_filter) +{ +long index =simple_strtoul (func_g->search,NULL ,0 ); +struct ftrace_page *pg; +struct dyn_ftrace *rec; + +/* The index starts at 1 */ +if (--index <0 ) +return 0 ; + +do_for_each_ftrace_rec (pg, rec) { +if (pg->index <= index) { + index -= pg->index; +/* this is a double loop, break goes to the next page */ +break ; + } + rec = &pg->records[index]; +enter_record (hash, rec, clear_filter); +return 1 ; + }while_for_each_ftrace_rec (); +return 0 ; +} +static int ftrace_match_record (struct dyn_ftrace *rec,struct ftrace_glob *func_g,struct ftrace_glob *mod_g,int exclude_mod)
@@ -3769,6 +3794,11 @@ match_records(struct ftrace_hash *hash, char *func, int len, char *mod)if (unlikely (ftrace_disabled)) goto out_unlock; +if (func_g.type ==MATCH_INDEX ) { + found =add_rec_by_index (hash, &func_g, clear_filter); + goto out_unlock; + } +do_for_each_ftrace_rec (pg, rec) {if (rec->flags &FTRACE_FL_DISABLED )
kernel/trace/trace.h +1 -0
@@ -1459,6 +1459,7 @@ enum regex_type {MATCH_MIDDLE_ONLY ,MATCH_END_ONLY ,MATCH_GLOB , + MATCH_INDEX, }; struct regex {
kernel/trace/trace_events_filter.c +5 -0
@@ -825,6 +825,9 @@ enum regex_type filter_parse_regex(char *buff, int len, char **search, int *not) *search = buff; +if (isdigit (buff[0 ])) +return MATCH_INDEX ; +for (i =0 ; i < len; i++) {if (buff[i] =='*' ) {if (!i) {
@@ -862,6 +865,8 @@ static void filter_build_regex(struct filter_pred *pred) }switch (type) { +/* MATCH_INDEX should not happen, but if it does, match full */ +case MATCH_INDEX :case MATCH_FULL : r->match = regex_match_full;break ;
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 12/29 uprobes: convert uprobe.ref to refcount_t
In reply to Steven RostedtFrom: Elena Reshetova <[email protected]>
atomic_t variables are currently used to implement reference counters with the following properties:
- counter is initialized to 1 using atomic_set()
- a resource is freed upon counter reaching zero
- once counter reaches zero, its further increments aren't allowed
- counter schema uses basic atomic operations (set, inc, inc_not_zero, dec_and_test, etc.)
Such atomic variables should be converted to a newly provided refcount_t type and API that prevents accidental counter overflows and underflows. This is important since overflows and underflows can lead to use-after-free situation and be exploitable.
The variable uprobe.ref is used as pure reference counter. Convert it to refcount_t and fix up the operations.
**Important note for maintainers:
Some functions from refcount_t API defined in lib/refcount.c have different memory ordering guarantees than their atomic counterparts.
The full comparison can be seen in
https://lkml.org/lkml/2017/11/15/57 and it is hopefully soon in state to be merged to the documentation tree.
Normally the differences should not matter since refcount_t provides enough guarantees to satisfy the refcounting use cases, but in some rare cases it might matter.
Please double check that you don't have some undocumented memory guarantees for this variable usage.
For the uprobe.ref it might make a difference
in following places:
- put_uprobe(): decrement in refcount_dec_and_test() only provides RELEASE ordering and control dependency on success vs. fully ordered atomic counterpart
--- kernel/events/uprobes.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
kernel/events/uprobes.c +4 -4
@@ -66,7 +66,7 @@ static struct percpu_rw_semaphore dup_mmap_sem;struct uprobe {struct rb_node rb_node;/* node in the rb tree */ -atomic_t ref; +refcount_t ref;struct rw_semaphore register_rwsem;struct rw_semaphore consumer_rwsem;struct list_head pending_list;
@@ -560,13 +560,13 @@ set_orig_insn(struct arch_uprobe *auprobe, struct mm_struct *mm, unsigned long vstatic struct uprobe *get_uprobe (struct uprobe *uprobe) { -atomic_inc (&uprobe->ref); +refcount_inc (&uprobe->ref);return uprobe; }static void put_uprobe (struct uprobe *uprobe) { -if (atomic_dec_and_test (&uprobe->ref)) { +if (refcount_dec_and_test (&uprobe->ref)) {/* * If application munmap(exec_vma) before uprobe_unregister() * gets called, we don't get a chance to remove uprobe from
@@ -657,7 +657,7 @@ static struct uprobe *__insert_uprobe(struct uprobe *uprobe)rb_link_node (&uprobe->rb_node, parent, p);rb_insert_color (&uprobe->rb_node, &uprobes_tree);/* get access + creation ref */ -atomic_set (&uprobe->ref,2 ); +refcount_set (&uprobe->ref,2 );return u; }
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 13/29 tracing: No need to free iter->trace in fail path of tracing_open_pipe()
In reply to Steven RostedtFrom: "zhangyi (F)" <[email protected]>
Commit d716ff71dd12 ("tracing: Remove taking of trace_types_lock in pipe files") use the current tracer instead of the copy in tracing_open_pipe(), but it forget to remove the freeing sentence in the error path.
[ Note, this is harmless because kfree(NULL) is allowed and iter is
allocated with kzalloc() making iter->trace = NULL -- S. Rostedt ]
--- kernel/trace/trace.c | 1 - 1 file changed, 1 deletion(-)
kernel/trace/trace.c +0 -1
@@ -5624,7 +5624,6 @@ static int tracing_open_pipe(struct inode *inode, struct file *filp)return ret; fail: -kfree (iter->trace);kfree (iter);__trace_array_put (tr);mutex_unlock (&trace_types_lock);
Signature · 1 line
2.20.1
Steven Rostedt
maintainerRe: [for-next][PATCH 13/29] tracing: No need to free iter->trace in fail path of tracing_open_pipe()
Quoted 9 lines · On Wed, 20 Feb 2019 13:37:50 -0500 Steven Rostedt <[email protected]> wrote:
From: "zhangyi (F)" <[email protected]>
Commit
d716ff71dd12("tracing: Remove taking oftrace_types_lockin pipe files") use the current tracer instead of the copy intracing_open_pipe(), but it forget to remove the freeing sentence in the error path.[ Note, this is harmless because kfree(NULL) is allowed and iter is
allocated withkzalloc()makingiter->trace= NULL -- S. Rostedt ]
Bah, I forgot to update this. I haven't pushed to linux-next yet.
As Zhangyi replied, this is a real issue. I just wished the real issue was explained in the change log.
I'm going to rebase this to update the change log (no code changes, so no need to run the tests again), and also, I'll add a Cc stable. No point in sending this out as a separate patch either, because the merge window is going to open soon.
-- Steve
Quoted 22 lines
Fixes d716ff71dd12 ("tracing: Remove taking of trace_types_lock in pipe files")Signed-off-by zhangyi (F) <[email protected]>Signed-off-by Steven Rostedt (VMware) <[email protected]>--- kernel/trace/trace.c | 1 - 1 file changed, 1 deletion(-)kernel/trace/trace.c +0
-1@@ -5624,7 +5624,6 @@ static int tracing_open_pipe(struct inode *inode, struct file *filp)return ret; fail: -kfree (iter->trace);kfree (iter);__trace_array_put (tr);mutex_unlock (&trace_types_lock);
Steven Rostedt
maintainerRe: [for-next][PATCH 13/29] tracing: No need to free iter->trace in fail path of tracing_open_pipe()
Here's the new patch change log:
From e7f0c424d0806b05d6f47be9f202b037eb701707 Mon Sep 17 00:00:00 2001
From: "zhangyi (F)" <[email protected]>
Date: Wed, 13 Feb 2019 20:29:06 +0800
Subject: [PATCH] tracing: Do not free iter->trace in fail path of
tracing_open_pipe()
Commit d716ff71dd12 ("tracing: Remove taking of trace_types_lock in pipe files") use the current tracer instead of the copy in tracing_open_pipe(), but it forget to remove the freeing sentence in the error path.
There's an error path that can call kfree(iter->trace) after the iter->trace was assigned to tr->current_trace, which would be bad to free.
--- kernel/trace/trace.c | 1 - 1 file changed, 1 deletion(-)
kernel/trace/trace.c +0 -1
@@ -5624,7 +5624,6 @@ static int tracing_open_pipe(struct inode *inode, struct file *filp)return ret; fail: -kfree (iter->trace);kfree (iter);__trace_array_put (tr);mutex_unlock (&trace_types_lock);
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 14/29 tracing: Refactor hist trigger action code
In reply to Steven RostedtFrom: Tom Zanussi <[email protected]>
The hist trigger action code currently implements two essentially hard-coded pairs of 'actions' - onmax(), which tracks a variable and saves some event fields when a max is hit, and onmatch(), which is hard-coded to generate a synthetic event.
These hardcoded pairs (track max/save fields and detect match/generate synthetic event) should really be decoupled into separate components that can then be arbitrarily combined. The first component of each pair (track max/detect match) is called a 'handler' in the new code, while the second component (save fields/generate synthetic event) is called an 'action' in this scheme.
This change refactors the action code to reflect this split by adding two handlers, HANDLER_ONMATCH and HANDLER_ONMAX, along with two actions, ACTION_SAVE and ACTION_TRACE.
The new code combines them to produce the existing ONMATCH/TRACE and ONMAX/SAVE functionality, but doesn't implement the other combinations now possible. Future patches will expand these to further useful cases, such as ONMAX/TRACE, as well as add additional handlers and actions such as ONCHANGE and SNAPSHOT.
Also, add abbreviated documentation for handlers and actions to README.
--- kernel/trace/trace_events_hist.c | 407 ++++++++++++++++++------------- 1 file changed, 238 insertions(+), 169 deletions(-)
kernel/trace/trace_events_hist.c +238 -169
@@ -313,9 +313,9 @@ struct hist_trigger_data {struct field_var_hist *field_var_hists[SYNTH_FIELDS_MAX ];unsigned int n_field_var_hists; -struct field_var *max_vars[SYNTH_FIELDS_MAX ]; -unsigned int n_max_vars; -unsigned int n_max_var_str; +struct field_var *save_vars[SYNTH_FIELDS_MAX ]; +unsigned int n_save_vars; +unsigned int n_save_var_str; };static int synth_event_create (int argc,const char **argv);
@@ -383,11 +383,25 @@ struct action_data;typedef void (*action_fn_t ) (struct hist_trigger_data *hist_data,struct tracing_map_elt *elt,void *rec, -struct ring_buffer_event *rbe, +struct ring_buffer_event *rbe,void *key,struct action_data *data,u64 *var_ref_vals); +enum handler_id { +HANDLER_ONMATCH =1 , +HANDLER_ONMAX , +}; + +enum action_id { +ACTION_SAVE =1 , +ACTION_TRACE , +}; +struct action_data { +enum handler_id handler; +enum action_id action; +char *action_name;action_fn_t fn; +unsigned int n_params;char *params[SYNTH_FIELDS_MAX ];
@@ -404,13 +418,11 @@ struct action_data {unsigned int var_ref_idx;char *match_event;char *match_event_system; -char *synth_event_name;struct synth_event *synth_event; } onmatch;struct {char *var_str; -char *fn_name;unsigned int max_var_ref_idx;struct hist_field *max_var;struct hist_field *var;
@@ -1078,7 +1090,7 @@ static struct synth_event *alloc_synth_event(const char *name, int n_fields,static void action_trace (struct hist_trigger_data *hist_data,struct tracing_map_elt *elt,void *rec, -struct ring_buffer_event *rbe, +struct ring_buffer_event *rbe,void *key,struct action_data *data,u64 *var_ref_vals) {struct synth_event *event = data->onmatch.synth_event;
@@ -1644,7 +1656,7 @@ find_match_var(struct hist_trigger_data *hist_data, char *var_name)for (i =0 ; i < hist_data->n_actions; i++) {struct action_data *data = hist_data->actions[i]; -if (data->fn == action_trace) { +if (data->handler ==HANDLER_ONMATCH ) {char *system = data->onmatch.match_event_system;char *event_name = data->onmatch.match_event;
@@ -2076,7 +2088,7 @@ static int hist_trigger_elt_data_alloc(struct tracing_map_elt *elt) } } - n_str = hist_data->n_field_var_str + hist_data->n_max_var_str; + n_str = hist_data->n_field_var_str + hist_data->n_save_var_str; size =STR_VAR_LEN_MAX ;
@@ -3050,7 +3062,7 @@ create_field_var_hist(struct hist_trigger_data *target_hist_data,int ret;if (target_hist_data->n_field_var_hists >=SYNTH_FIELDS_MAX ) { -hist_err_event ("onmatch: Too many field variables defined: " , +hist_err_event ("trace action: Too many field variables defined: " , subsys_name, event_name, field_name);return ERR_PTR (-EINVAL ); }
@@ -3058,7 +3070,7 @@ create_field_var_hist(struct hist_trigger_data *target_hist_data, file =event_file (tr, subsys_name, event_name);if (IS_ERR (file)) { -hist_err_event ("onmatch: Event file not found: " , +hist_err_event ("trace action: Event file not found: " , subsys_name, event_name, field_name); ret =PTR_ERR (file);return ERR_PTR (ret);
@@ -3072,7 +3084,7 @@ create_field_var_hist(struct hist_trigger_data *target_hist_data,*/ hist_data =find_compatible_hist (target_hist_data, file);if (!hist_data) { -hist_err_event ("onmatch: Matching event histogram not found: " , +hist_err_event ("trace action: Matching event histogram not found: " , subsys_name, event_name, field_name);return ERR_PTR (-EINVAL ); }
@@ -3134,7 +3146,7 @@ create_field_var_hist(struct hist_trigger_data *target_hist_data,kfree (cmd);kfree (var_hist->cmd);kfree (var_hist); -hist_err_event ("onmatch: Couldn't create histogram for field: " , +hist_err_event ("trace action: Couldn't create histogram for field: " , subsys_name, event_name, field_name);return ERR_PTR (ret); }
@@ -3147,7 +3159,7 @@ create_field_var_hist(struct hist_trigger_data *target_hist_data,if (IS_ERR_OR_NULL (event_var)) {kfree (var_hist->cmd);kfree (var_hist); -hist_err_event ("onmatch: Couldn't find synthetic variable: " , +hist_err_event ("trace action: Couldn't find synthetic variable: " , subsys_name, event_name, field_name);return ERR_PTR (-EINVAL ); }
@@ -3230,8 +3242,8 @@ static void update_max_vars(struct hist_trigger_data *hist_data,struct ring_buffer_event *rbe, void *rec) { - __update_field_vars(elt, rbe, rec, hist_data->max_vars, - hist_data->n_max_vars, hist_data->n_field_var_str); + __update_field_vars(elt, rbe, rec, hist_data->save_vars, + hist_data->n_save_vars, hist_data->n_field_var_str); } static struct hist_field *create_var(struct hist_trigger_data *hist_data,
@@ -3375,9 +3387,9 @@ static void onmax_print(struct seq_file *m,seq_printf (m,"\n\tmax: %10llu" ,tracing_map_read_var (elt, max_idx)); -for (i =0 ; i < hist_data->n_max_vars; i++) { -struct hist_field *save_val = hist_data->max_vars[i]->val; -struct hist_field *save_var = hist_data->max_vars[i]->var; +for (i =0 ; i < hist_data->n_save_vars; i++) { +struct hist_field *save_val = hist_data->save_vars[i]->val; +struct hist_field *save_var = hist_data->save_vars[i]->var;u64 val; save_var_idx = save_var->var.idx;
@@ -3394,7 +3406,7 @@ static void onmax_print(struct seq_file *m,static void onmax_save (struct hist_trigger_data *hist_data,struct tracing_map_elt *elt,void *rec, -struct ring_buffer_event *rbe, +struct ring_buffer_event *rbe,void *key,struct action_data *data,u64 *var_ref_vals) {unsigned int max_idx = data->onmax.max_var->var.idx;
@@ -3421,7 +3433,7 @@ static void onmax_destroy(struct action_data *data)destroy_hist_field (data->onmax.var,0 );kfree (data->onmax.var_str); -kfree (data->onmax.fn_name); +kfree (data->action_name);for (i =0 ; i < data->n_params; i++)kfree (data->params[i]);
@@ -3429,15 +3441,16 @@ static void onmax_destroy(struct action_data *data)kfree (data); } +static int action_create (struct hist_trigger_data *hist_data, +struct action_data *data); +static int onmax_create (struct hist_trigger_data *hist_data,struct action_data *data) { +struct hist_field *var_field, *ref_field, *max_var =NULL ;struct trace_event_file *file = hist_data->event_file; -struct hist_field *var_field, *ref_field, *max_var;unsigned int var_ref_idx = hist_data->n_var_refs; -struct field_var *field_var; -char *onmax_var_str, *param; -unsigned int i; +char *onmax_var_str;int ret =0 ; onmax_var_str = data->onmax.var_str;
@@ -3459,8 +3472,8 @@ static int onmax_create(struct hist_trigger_data *hist_data, data->onmax.var = ref_field; - data->fn = onmax_save; data->onmax.max_var_ref_idx = var_ref_idx; + max_var =create_var (hist_data, file,"max" ,sizeof (u64),"u64" );if (IS_ERR (max_var)) {hist_err ("onmax: Couldn't create onmax variable: " ,"max" );
@@ -3469,27 +3482,7 @@ static int onmax_create(struct hist_trigger_data *hist_data, } data->onmax.max_var = max_var; -for (i =0 ; i < data->n_params; i++) { - param =kstrdup (data->params[i],GFP_KERNEL ); -if (!param) { - ret = -ENOMEM ; - goto out; - } - - field_var =create_target_field_var (hist_data,NULL ,NULL , param); -if (IS_ERR (field_var)) { -hist_err ("onmax: Couldn't create field variable: " , param); - ret =PTR_ERR (field_var); -kfree (param); - goto out; - } - - hist_data->max_vars[hist_data->n_max_vars++] = field_var; -if (field_var->val->flags &HIST_FIELD_FL_STRING ) - hist_data->n_max_var_str++; - -kfree (param); - } + ret =action_create (hist_data, data); out:return ret; }
@@ -3500,11 +3493,14 @@ static int parse_action_params(char *params, struct action_data *data)int ret =0 ;while (params) { -if (data->n_params >=SYNTH_FIELDS_MAX ) +if (data->n_params >=SYNTH_FIELDS_MAX ) { +hist_err ("Too many action params" ,"" ); goto out; + } param =strsep (¶ms,"," );if (!param) { +hist_err ("No action param found" ,"" ); ret = -EINVAL ; goto out; }
@@ -3528,10 +3524,71 @@ static int parse_action_params(char *params, struct action_data *data)return ret; } -static struct action_data *onmax_parse (char *str) +static int action_parse (char *str,struct action_data *data, +enum handler_id handler) +{ +char *action_name; +int ret =0 ; + +strsep (&str,"." ); +if (!str) { +hist_err ("action parsing: No action found" ,"" ); + ret = -EINVAL ; + goto out; + } + + action_name =strsep (&str,"(" ); +if (!action_name || !str) { +hist_err ("action parsing: No action found" ,"" ); + ret = -EINVAL ; + goto out; + } + +if (str_has_prefix (action_name,"save" )) { +char *params =strsep (&str,")" ); + +if (!params) { +hist_err ("action parsing: No params found for %s" ,"save" ); + ret = -EINVAL ; + goto out; + } + + ret =parse_action_params (params, data); +if (ret) + goto out; + +if (handler ==HANDLER_ONMAX ) + data->fn = onmax_save; + + data->action =ACTION_SAVE ; + }else { +char *params =strsep (&str,")" ); + +if (params) { + ret =parse_action_params (params, data); +if (ret) + goto out; + } + + data->fn = action_trace; + data->action =ACTION_TRACE ; + } + + data->action_name =kstrdup (action_name,GFP_KERNEL ); +if (!data->action_name) { + ret = -ENOMEM ; + goto out; + } + + data->handler = handler; + out: +return ret; +} + +static struct action_data *onmax_parse (char *str,enum handler_id handler) { -char *onmax_fn_name, *onmax_var_str;struct action_data *data; +char *onmax_var_str;int ret = -EINVAL ; data =kzalloc (sizeof (*data),GFP_KERNEL );
@@ -3550,33 +3607,9 @@ static struct action_data *onmax_parse(char *str) goto free; } -strsep (&str,"." ); -if (!str) - goto free; - - onmax_fn_name =strsep (&str,"(" ); -if (!onmax_fn_name || !str) - goto free; - -if (str_has_prefix (onmax_fn_name,"save" )) { -char *params =strsep (&str,")" ); - -if (!params) { - ret = -EINVAL ; - goto free; - } - - ret =parse_action_params (params, data); -if (ret) - goto free; - }else - goto free; - - data->onmax.fn_name =kstrdup (onmax_fn_name,GFP_KERNEL ); -if (!data->onmax.fn_name) { - ret = -ENOMEM ; + ret =action_parse (str, data, handler); +if (ret) goto free; - } out:return data; free:
@@ -3593,7 +3626,7 @@ static void onmatch_destroy(struct action_data *data)kfree (data->onmatch.match_event);kfree (data->onmatch.match_event_system); -kfree (data->onmatch.synth_event_name); +kfree (data->action_name);for (i =0 ; i < data->n_params; i++)kfree (data->params[i]);
@@ -3651,8 +3684,9 @@ static int check_synth_field(struct synth_event *event, }static struct hist_field * -onmatch_find_var (struct hist_trigger_data *hist_data,struct action_data *data, -char *system,char *event,char *var) +trace_action_find_var (struct hist_trigger_data *hist_data, +struct action_data *data, +char *system,char *event,char *var) {struct hist_field *hist_field;
@@ -3660,7 +3694,7 @@ onmatch_find_var(struct hist_trigger_data *hist_data, struct action_data *data, hist_field =find_target_event_var (hist_data, system, event, var);if (!hist_field) { -if (!system) { +if (!system && data->handler ==HANDLER_ONMATCH ) { system = data->onmatch.match_event_system; event = data->onmatch.match_event; }
@@ -3669,15 +3703,15 @@ onmatch_find_var(struct hist_trigger_data *hist_data, struct action_data *data, }if (!hist_field) -hist_err_event ("onmatch: Couldn't find onmatch param: $" , system, event, var); +hist_err_event ("trace action: Couldn't find param: $" , system, event, var);return hist_field; }static struct hist_field * -onmatch_create_field_var (struct hist_trigger_data *hist_data, -struct action_data *data,char *system, -char *event,char *var) +trace_action_create_field_var (struct hist_trigger_data *hist_data, +struct action_data *data,char *system, +char *event,char *var) {struct hist_field *hist_field =NULL ;struct field_var *field_var;
@@ -3700,7 +3734,7 @@ onmatch_create_field_var(struct hist_trigger_data *hist_data,* looking for fields on the onmatch(system.event.xxx) * event. */ -if (!system) { +if (!system && data->handler ==HANDLER_ONMATCH ) { system = data->onmatch.match_event_system; event = data->onmatch.match_event; }
@@ -3724,9 +3758,8 @@ onmatch_create_field_var(struct hist_trigger_data *hist_data, goto out; } -static int onmatch_create (struct hist_trigger_data *hist_data, -struct trace_event_file *file, -struct action_data *data) +static int trace_action_create (struct hist_trigger_data *hist_data, +struct action_data *data) {char *event_name, *param, *system =NULL ;struct hist_field *hist_field, *var_ref;
@@ -3737,11 +3770,12 @@ static int onmatch_create(struct hist_trigger_data *hist_data,lockdep_assert_held (&event_mutex); - event =find_synth_event (data->onmatch.synth_event_name); + event =find_synth_event (data->action_name);if (!event) { -hist_err ("onmatch: Couldn't find synthetic event: " , data->onmatch.synth_event_name); +hist_err ("trace action: Couldn't find synthetic event: " , data->action_name);return -EINVAL ; } + event->ref++; var_ref_idx = hist_data->n_var_refs;
@@ -3769,13 +3803,15 @@ static int onmatch_create(struct hist_trigger_data *hist_data, }if (param[0 ] =='$' ) - hist_field =onmatch_find_var (hist_data, data, system, - event_name, param); + hist_field =trace_action_find_var (hist_data, data, + system, event_name, + param);else - hist_field =onmatch_create_field_var (hist_data, data, - system, - event_name, - param); + hist_field =trace_action_create_field_var (hist_data, + data, + system, + event_name, + param);if (!hist_field) {kfree (p);
@@ -3797,7 +3833,7 @@ static int onmatch_create(struct hist_trigger_data *hist_data,continue ; } -hist_err_event ("onmatch: Param type doesn't match synthetic event field type: " , +hist_err_event ("trace action: Param type doesn't match synthetic event field type: " , system, event_name, param);kfree (p); ret = -EINVAL ;
@@ -3805,12 +3841,11 @@ static int onmatch_create(struct hist_trigger_data *hist_data, }if (field_pos != event->n_fields) { -hist_err ("onmatch: Param count doesn't match synthetic event field count: " , event->name); +hist_err ("trace action: Param count doesn't match synthetic event field count: " , event->name); ret = -EINVAL ; goto err; } - data->fn = action_trace; data->onmatch.synth_event = event; data->onmatch.var_ref_idx = var_ref_idx; out:
@@ -3821,10 +3856,58 @@ static int onmatch_create(struct hist_trigger_data *hist_data, goto out; } +static int action_create (struct hist_trigger_data *hist_data, +struct action_data *data) +{ +struct field_var *field_var; +unsigned int i; +char *param; +int ret =0 ; + +if (data->action ==ACTION_TRACE ) +return trace_action_create (hist_data, data); + +if (data->action ==ACTION_SAVE ) { +if (hist_data->n_save_vars) { + ret = -EEXIST ; +hist_err ("save action: Can't have more than one save() action per hist" ,"" ); + goto out; + } + +for (i =0 ; i < data->n_params; i++) { + param =kstrdup (data->params[i],GFP_KERNEL ); +if (!param) { + ret = -ENOMEM ; + goto out; + } + + field_var =create_target_field_var (hist_data,NULL ,NULL , param); +if (IS_ERR (field_var)) { +hist_err ("save action: Couldn't create field variable: " , param); + ret =PTR_ERR (field_var); +kfree (param); + goto out; + } + + hist_data->save_vars[hist_data->n_save_vars++] = field_var; +if (field_var->val->flags &HIST_FIELD_FL_STRING ) + hist_data->n_save_var_str++; +kfree (param); + } + } + out: +return ret; +} + +static int onmatch_create (struct hist_trigger_data *hist_data, +struct action_data *data) +{ +return action_create (hist_data, data); +} +static struct action_data *onmatch_parse (struct trace_array *tr,char *str) {char *match_event, *match_event_system; -char *synth_event_name, *params;struct action_data *data;int ret = -EINVAL ;
@@ -3862,31 +3945,7 @@ static struct action_data *onmatch_parse(struct trace_array *tr, char *str) goto free; } -strsep (&str,"." ); -if (!str) { -hist_err ("onmatch: Missing . after onmatch(): " , str); - goto free; - } - - synth_event_name =strsep (&str,"(" ); -if (!synth_event_name || !str) { -hist_err ("onmatch: Missing opening paramlist paren: " , synth_event_name); - goto free; - } - - data->onmatch.synth_event_name =kstrdup (synth_event_name,GFP_KERNEL ); -if (!data->onmatch.synth_event_name) { - ret = -ENOMEM ; - goto free; - } - - params =strsep (&str,")" ); -if (!params || !str || (str &&strlen (str))) { -hist_err ("onmatch: Missing closing paramlist paren: " , params); - goto free; - } - - ret =parse_action_params (params, data); + ret =action_parse (str, data,HANDLER_ONMATCH );if (ret) goto free; out:
@@ -4326,9 +4385,9 @@ static void destroy_actions(struct hist_trigger_data *hist_data)for (i =0 ; i < hist_data->n_actions; i++) {struct action_data *data = hist_data->actions[i]; -if (data->fn == action_trace) +if (data->handler ==HANDLER_ONMATCH )onmatch_destroy (data); -else if (data->fn == onmax_save) +else if (data->handler ==HANDLER_ONMAX )onmax_destroy (data);else kfree (data);
@@ -4355,16 +4414,14 @@ static int parse_actions(struct hist_trigger_data *hist_data) ret =PTR_ERR (data);break ; } - data->fn = action_trace; }else if ((len =str_has_prefix (str,"onmax(" ))) {char *action_str = str + len; - data =onmax_parse (action_str); + data =onmax_parse (action_str,HANDLER_ONMAX );if (IS_ERR (data)) { ret =PTR_ERR (data);break ; } - data->fn = onmax_save; }else { ret = -EINVAL ;break ;
@@ -4376,8 +4433,7 @@ static int parse_actions(struct hist_trigger_data *hist_data)return ret; } -static int create_actions (struct hist_trigger_data *hist_data, -struct trace_event_file *file) +static int create_actions (struct hist_trigger_data *hist_data) {struct action_data *data;unsigned int i;
@@ -4386,14 +4442,17 @@ static int create_actions(struct hist_trigger_data *hist_data,for (i =0 ; i < hist_data->attrs->n_actions; i++) { data = hist_data->actions[i]; -if (data->fn == action_trace) { - ret =onmatch_create (hist_data, file, data); +if (data->handler ==HANDLER_ONMATCH ) { + ret =onmatch_create (hist_data, data);if (ret) -return ret; - }else if (data->fn == onmax_save) { +break ; + }else if (data->handler ==HANDLER_ONMAX ) { ret =onmax_create (hist_data, data);if (ret) -return ret; +break ; + }else { + ret = -EINVAL ; +break ; } }
@@ -4409,26 +4468,42 @@ static void print_actions(struct seq_file *m,for (i =0 ; i < hist_data->n_actions; i++) {struct action_data *data = hist_data->actions[i]; -if (data->fn == onmax_save) +if (data->handler ==HANDLER_ONMAX )onmax_print (m, hist_data, elt, data); } } +static void print_action_spec (struct seq_file *m, +struct hist_trigger_data *hist_data, +struct action_data *data) +{ +unsigned int i; + +if (data->action ==ACTION_SAVE ) { +for (i =0 ; i < hist_data->n_save_vars; i++) { +seq_printf (m,"%s" , hist_data->save_vars[i]->var->var.name); +if (i < hist_data->n_save_vars -1 ) +seq_puts (m,"," ); + } + }else if (data->action ==ACTION_TRACE ) { +for (i =0 ; i < data->n_params; i++) { +if (i) +seq_puts (m,"," ); +seq_printf (m,"%s" , data->params[i]); + } + } +} +static void print_onmax_spec (struct seq_file *m,struct hist_trigger_data *hist_data,struct action_data *data) { -unsigned int i; -seq_puts (m,":onmax(" );seq_printf (m,"%s" , data->onmax.var_str); -seq_printf (m,").%s(" , data->onmax.fn_name); +seq_printf (m,").%s(" , data->action_name); + +print_action_spec (m, hist_data, data); -for (i =0 ; i < hist_data->n_max_vars; i++) { -seq_printf (m,"%s" , hist_data->max_vars[i]->var->var.name); -if (i < hist_data->n_max_vars -1 ) -seq_puts (m,"," ); - }seq_puts (m,")" ); }
@@ -4436,18 +4511,12 @@ static void print_onmatch_spec(struct seq_file *m, struct hist_trigger_data *hist_data, struct action_data *data) { - unsigned int i; - seq_printf(m, ":onmatch(%s.%s).", data->onmatch.match_event_system, data->onmatch.match_event); -seq_printf (m,"%s(" , data->onmatch.synth_event->name); +seq_printf (m,"%s(" , data->action_name); -for (i =0 ; i < data->n_params; i++) { -if (i) -seq_puts (m,"," ); -seq_printf (m,"%s" , data->params[i]); - } +print_action_spec (m, hist_data, data);seq_puts (m,")" ); }
@@ -4464,7 +4533,9 @@ static bool actions_match(struct hist_trigger_data *hist_data,struct action_data *data = hist_data->actions[i];struct action_data *data_test = hist_data_test->actions[i]; -if (data->fn != data_test->fn) +if (data->handler != data_test->handler) +return false; +if (data->action != data_test->action)return false;if (data->n_params != data_test->n_params)
@@ -4475,23 +4546,20 @@ static bool actions_match(struct hist_trigger_data *hist_data,return false; } -if (data->fn == action_trace) { -if (strcmp (data->onmatch.synth_event_name, - data_test->onmatch.synth_event_name) !=0 ) -return false; +if (strcmp (data->action_name, data_test->action_name) !=0 ) +return false; + +if (data->handler ==HANDLER_ONMATCH ) {if (strcmp (data->onmatch.match_event_system, data_test->onmatch.match_event_system) !=0 )return false;if (strcmp (data->onmatch.match_event, data_test->onmatch.match_event) !=0 )return false; - }else if (data->fn == onmax_save) { + }else if (data->handler ==HANDLER_ONMAX ) {if (strcmp (data->onmax.var_str, data_test->onmax.var_str) !=0 )return false; -if (strcmp (data->onmax.fn_name, - data_test->onmax.fn_name) !=0 ) -return false; } }
@@ -4507,9 +4575,9 @@ static void print_actions_spec(struct seq_file *m,for (i =0 ; i < hist_data->n_actions; i++) {struct action_data *data = hist_data->actions[i]; -if (data->fn == action_trace) +if (data->handler ==HANDLER_ONMATCH )print_onmatch_spec (m, hist_data, data); -else if (data->fn == onmax_save) +else if (data->handler ==HANDLER_ONMAX )print_onmax_spec (m, hist_data, data); } }
@@ -4703,14 +4771,15 @@ static inline void add_to_key(char *compound_key, void *key,static void hist_trigger_actions (struct hist_trigger_data *hist_data,struct tracing_map_elt *elt,void *rec, -struct ring_buffer_event *rbe,u64 *var_ref_vals) +struct ring_buffer_event *rbe,void *key, +u64 *var_ref_vals) {struct action_data *data;unsigned int i;for (i =0 ; i < hist_data->n_actions; i++) { data = hist_data->actions[i]; - data->fn (hist_data, elt, rec, rbe, data, var_ref_vals); + data->fn (hist_data, elt, rec, rbe, key, data, var_ref_vals); } }
@@ -4771,7 +4840,7 @@ static void event_hist_trigger(struct event_trigger_data *data, void *rec,hist_trigger_elt_update (hist_data, elt, rec, rbe, var_ref_vals);if (resolve_var_refs (hist_data, key, var_ref_vals, true)) -hist_trigger_actions (hist_data, elt, rec, rbe, var_ref_vals); +hist_trigger_actions (hist_data, elt, rec, rbe, key, var_ref_vals); } static void hist_trigger_stacktrace_print(struct seq_file *m,
@@ -5683,7 +5752,7 @@ static int event_hist_trigger_func(struct event_command *cmd_ops,if (has_hist_vars (hist_data))save_hist_vars (hist_data); - ret =create_actions (hist_data, file); + ret =create_actions (hist_data);if (ret) goto out_unreg;
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 15/29 tracing: Make hist trigger Documentation better reflect actions/handlers
In reply to Steven RostedtFrom: Tom Zanussi <[email protected]>
The action/handler code refactoring didn't change the action/handler syntax, but did generalize it - the Documentation should reflect that.
--- Documentation/trace/histogram.rst | 56 ++++++++++++++++++++++++------- 1 file changed, 43 insertions(+), 13 deletions(-)
Documentation/trace/histogram.rst +43 -13
@@ -25,7 +25,7 @@ Documentation written by Tom Zanussi hist:keys=<field1[,field2,...]>[:values=<field1[,field2,...]>] [:sort=<field1[,field2,...]>][:size=#entries][:pause][:continue] - [:clear][:name=histname1] [if <filter>] + [:clear][:name=histname1][:<handler>.<action>] [if <filter>] When a matching event is hit, an entry is added to a hash table using the key(s) and value(s) named. Keys and values correspond to
@@ -1831,21 +1831,51 @@ and looks and behaves just like any other event:: Like any other event, once a histogram is enabled for the event, the output can be displayed by reading the event's 'hist' file. -2.2.3 Hist trigger 'actions' ----------------------------- +2.2.3 Hist trigger 'handlers' and 'actions' +------------------------------------------- -A hist trigger 'action' is a function that's executed whenever a -histogram entry is added or updated. +A hist trigger 'action' is a function that's executed (in most cases +conditionally) whenever a histogram entry is added or updated. -The default 'action' if no special function is explicitly specified is -as it always has been, to simply update the set of values associated -with an entry. Some applications, however, may want to perform -additional actions at that point, such as generate another event, or -compare and save a maximum. +When a histogram entry is added or updated, a hist trigger 'handler' +is what decides whether the corresponding action is actually invoked +or not. -The following additional actions are available. To specify an action -for a given event, simply specify the action between colons in the -hist trigger specification. +Hist trigger handlers and actions are paired together in the general +form: + + <handler>.<action> + +To specify a handler.action pair for a given event, simply specify +that handler.action pair between colons in the hist trigger +specification. + +In theory, any handler can be combined with any action, but in +practice, not every handler.action combination is currently supported; +if a given handler.action combination isn't supported, the hist +trigger will fail with -EINVAL; + +The default 'handler.action' if none is explicity specified is as it +always has been, to simply update the set of values associated with an +entry. Some applications, however, may want to perform additional +actions at that point, such as generate another event, or compare and +save a maximum. + +The supported handlers and actions are listed below, and each is +described in more detail in the following paragraphs, in the context +of descriptions of some common and useful handler.action combinations. + +The available handlers are: + + - onmatch(matching.event) - invoke action on any addition or update + - onmax(var) - invoke action if var exceeds current max + +The available actions are: + + - <synthetic_event_name>(param list) - generate synthetic event + - save(field,...) - save current event fields + +The following commonly-used handler.action pairs are available: - onmatch(matching.event).<synthetic_event_name>(param list)
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 16/29 tracing: Split up onmatch action data
In reply to Steven RostedtFrom: Tom Zanussi <[email protected]>
Currently, the onmatch action data binds the onmatch action to data related to synthetic event generation. Since we want to allow the onmatch handler to potentially invoke a different action, and because we expect other handlers to generate synthetic events, we need to separate the data related to these two functions.
Also rename the onmatch data to something more descriptive, and create and use common action data destroy function.
--- kernel/trace/trace.c | 12 +++- kernel/trace/trace_events_hist.c | 103 ++++++++++++++++--------------- 2 files changed, 63 insertions(+), 52 deletions(-)
kernel/trace/trace.c +11 -1
@@ -4700,6 +4700,7 @@ static const char readme_msg[] ="\t [:size=#entries]\n" "\t [:pause][:continue][:clear]\n" "\t [:name=histname1]\n" +"\t [:<handler>.<action>]\n" "\t [if <filter>]\n\n" "\t When a matching event is hit, an entry is added to a hash\n" "\t table using the key(s) and value(s) named, and the value of a\n"
@@ -4741,7 +4742,16 @@ static const char readme_msg[] ="\t The enable_hist and disable_hist triggers can be used to\n" "\t have one event conditionally start and stop another event's\n" "\t already-attached hist trigger. The syntax is analagous to\n" - "\t the enable_event and disable_event triggers.\n" +"\t the enable_event and disable_event triggers.\n\n" +"\t Hist trigger handlers and actions are executed whenever a\n" +"\t a histogram entry is added or updated. They take the form:\n\n" +"\t <handler>.<action>\n\n" +"\t The available handlers are:\n\n" +"\t onmatch(matching.event) - invoke on addition or update\n" +"\t onmax(var) - invoke if var exceeds current max\n\n" +"\t The available actions are:\n\n" +"\t <synthetic_event>(param list) - generate synthetic event\n" + "\t save(field,...) - save current event fields\n"#endif ;
kernel/trace/trace_events_hist.c +52 -51
190 lines not on this page · raw message
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 17/29 tracing: Generalize hist trigger onmax and save action
In reply to Steven RostedtFrom: Tom Zanussi <[email protected]>
The action refactor code allowed actions and handlers to be separated, but the existing onmax handler and save action code is still not flexible enough to handle arbitrary coupling. This change generalizes them and in the process makes additional handlers and actions easier to implement.
The onmax action can be broken up and thought of as two separate components - a variable to be tracked (the parameter given to the onmax($var_to_track) function) and an invisible variable created to save the ongoing result of doing something with that variable, such as saving the max value of that variable so far seen.
Separating it out like this and renaming it appropriately allows us to use the same code for similar tracking functions such as onchange($var_to_track), which would just track the last value seen rather than the max seen so far, which is useful in some situations.
Additionally, because different handlers and actions may want to save and access data differently e.g. save and retrieve tracking values as local variables vs something more global, save_val() and get_val() interface functions are introduced and max-specific implementations are used instead.
The same goes for the code that checks whether a maximum has been hit
- a generic check_val() interface and max-checking implementation is used instead, which allows future patches to make use of he same code using their own implemetations of similar functionality.
--- kernel/trace/trace_events_hist.c | 236 +++++++++++++++++++++---------- 1 file changed, 160 insertions(+), 76 deletions(-)
kernel/trace/trace_events_hist.c +160 -76
@@ -386,6 +386,8 @@ typedef void (*action_fn_t) (struct hist_trigger_data *hist_data, struct ring_buffer_event *rbe, void *key, struct action_data *data, u64 *var_ref_vals); +typedef bool (*check_track_val_fn_t ) (u64 track_val,u64 var_val); +enum handler_id {HANDLER_ONMATCH =1 ,HANDLER_ONMAX ,
@@ -423,15 +425,35 @@ struct action_data { } match_data;struct { +/* +* var_str contains the $-unstripped variable +* name referenced by var_ref, and used when +* printing the action. Because var_ref +* creation is deferred to create_actions(), +* we need a per-action way to save it until +* then, thus var_str. +*/ char *var_str; -unsigned int max_var_ref_idx; -struct hist_field *max_var; -struct hist_field *var; - } onmax; + +/* +* var_ref refers to the variable being +* tracked e.g onmax($var). +*/ +struct hist_field *var_ref; + +/* +* track_var contains the 'invisible' tracking +* variable created to keep the current +* e.g. max value. +*/ +struct hist_field *track_var; + +check_track_val_fn_t check_val; +action_fn_t save_data; + } track_data; }; }; -static char last_hist_cmd[MAX_FILTER_STR_VAL ];static char hist_err_str[MAX_FILTER_STR_VAL ];
@@ -3238,10 +3260,10 @@ static void update_field_vars(struct hist_trigger_data *hist_data, hist_data->n_field_vars, 0); } -static void update_max_vars (struct hist_trigger_data *hist_data, -struct tracing_map_elt *elt, -struct ring_buffer_event *rbe, -void *rec) +static void save_track_data_vars (struct hist_trigger_data *hist_data, +struct tracing_map_elt *elt,void *rec, +struct ring_buffer_event *rbe,void *key, +struct action_data *data,u64 *var_ref_vals) {__update_field_vars (elt, rbe, rec, hist_data->save_vars, hist_data->n_save_vars, hist_data->n_field_var_str);
@@ -3379,14 +3401,67 @@ create_target_field_var(struct hist_trigger_data *target_hist_data,return create_field_var (target_hist_data, file, var_name); } -static void onmax_print (struct seq_file *m, -struct hist_trigger_data *hist_data, -struct tracing_map_elt *elt, -struct action_data *data) +static bool check_track_val_max (u64 track_val,u64 var_val) +{ +if (var_val <= track_val) +return false; + +return true; +} + +static u64 get_track_val (struct hist_trigger_data *hist_data, +struct tracing_map_elt *elt, +struct action_data *data) { -unsigned int i, save_var_idx, max_idx = data->onmax.max_var->var.idx; +unsigned int track_var_idx = data->track_data.track_var->var.idx; +u64 track_val; + + track_val =tracing_map_read_var (elt, track_var_idx); -seq_printf (m,"\n\tmax: %10llu" ,tracing_map_read_var (elt, max_idx)); +return track_val; +} + +static void save_track_val (struct hist_trigger_data *hist_data, +struct tracing_map_elt *elt, +struct action_data *data,u64 var_val) +{ +unsigned int track_var_idx = data->track_data.track_var->var.idx; + +tracing_map_set_var (elt, track_var_idx, var_val); +} + +static void save_track_data (struct hist_trigger_data *hist_data, +struct tracing_map_elt *elt,void *rec, +struct ring_buffer_event *rbe,void *key, +struct action_data *data,u64 *var_ref_vals) +{ +if (data->track_data.save_data) + data->track_data.save_data (hist_data, elt, rec, rbe, key, data, var_ref_vals); +} + +static bool check_track_val (struct tracing_map_elt *elt, +struct action_data *data, +u64 var_val) +{ +struct hist_trigger_data *hist_data; +u64 track_val; + + hist_data = data->track_data.track_var->hist_data; + track_val =get_track_val (hist_data, elt, data); + +return data->track_data.check_val (track_val, var_val); +} + +static void track_data_print (struct seq_file *m, +struct hist_trigger_data *hist_data, +struct tracing_map_elt *elt, +struct action_data *data) +{ +u64 track_val =get_track_val (hist_data, elt, data); +unsigned int i, save_var_idx; + +if (data->handler ==HANDLER_ONMAX ) +seq_printf (m,"\n\tmax: %10llu" , track_val);for (i =0 ; i < hist_data->n_save_vars; i++) {struct hist_field *save_val = hist_data->save_vars[i]->val;
@@ -3405,25 +3480,17 @@ static void onmax_print(struct seq_file *m, } } -static void onmax_save (struct hist_trigger_data *hist_data, -struct tracing_map_elt *elt,void *rec, -struct ring_buffer_event *rbe,void *key, -struct action_data *data,u64 *var_ref_vals) +static void ontrack_action (struct hist_trigger_data *hist_data, +struct tracing_map_elt *elt,void *rec, +struct ring_buffer_event *rbe,void *key, +struct action_data *data,u64 *var_ref_vals) { -unsigned int max_idx = data->onmax.max_var->var.idx; -unsigned int max_var_ref_idx = data->onmax.max_var_ref_idx; +u64 var_val = var_ref_vals[data->track_data.var_ref->var_ref_idx]; -u64 var_val, max_val; - - var_val = var_ref_vals[max_var_ref_idx]; - max_val =tracing_map_read_var (elt, max_idx); - -if (var_val <= max_val) -return ; - -tracing_map_set_var (elt, max_idx, var_val); - -update_max_vars (hist_data, elt, rbe, rec); +if (check_track_val (elt, data, var_val)) { +save_track_val (hist_data, elt, data, var_val); +save_track_data (hist_data, elt, rec, rbe, key, data, var_ref_vals); + } }static void action_data_destroy (struct action_data *data)
@@ -3443,12 +3510,13 @@ static void action_data_destroy(struct action_data *data)kfree (data); } -static void onmax_destroy (struct action_data *data) +static void track_data_destroy (struct hist_trigger_data *hist_data, +struct action_data *data) { -destroy_hist_field (data->onmax.max_var,0 ); -destroy_hist_field (data->onmax.var,0 ); +destroy_hist_field (data->track_data.track_var,0 ); +destroy_hist_field (data->track_data.var_ref,0 ); -kfree (data->onmax.var_str); +kfree (data->track_data.var_str);action_data_destroy (data); }
@@ -3456,25 +3524,24 @@ static void onmax_destroy(struct action_data *data)static int action_create (struct hist_trigger_data *hist_data,struct action_data *data); -static int onmax_create (struct hist_trigger_data *hist_data, -struct action_data *data) +static int track_data_create (struct hist_trigger_data *hist_data, +struct action_data *data) { -struct hist_field *var_field, *ref_field, *max_var =NULL ; +struct hist_field *var_field, *ref_field, *track_var =NULL ;struct trace_event_file *file = hist_data->event_file; -unsigned int var_ref_idx = hist_data->n_var_refs; -char *onmax_var_str; +char *track_data_var_str;int ret =0 ; - onmax_var_str = data->onmax.var_str; -if (onmax_var_str[0 ] !='$' ) { -hist_err ("onmax: For onmax(x), x must be a variable: " , onmax_var_str); + track_data_var_str = data->track_data.var_str; +if (track_data_var_str[0 ] !='$' ) { +hist_err ("For onmax(x), x must be a variable: " , track_data_var_str);return -EINVAL ; } - onmax_var_str++; + track_data_var_str++; - var_field =find_target_event_var (hist_data,NULL ,NULL , onmax_var_str); + var_field =find_target_event_var (hist_data,NULL ,NULL , track_data_var_str);if (!var_field) { -hist_err ("onmax: Couldn't find onmax variable: " , onmax_var_str); +hist_err ("Couldn't find onmax variable: " , track_data_var_str);return -EINVAL ; }
@@ -3482,17 +3549,16 @@ static int onmax_create(struct hist_trigger_data *hist_data,if (!ref_field)return -ENOMEM ; - data->onmax.var = ref_field; + data->track_data.var_ref = ref_field; - data->onmax.max_var_ref_idx = var_ref_idx; - - max_var =create_var (hist_data, file,"max" ,sizeof (u64),"u64" ); -if (IS_ERR (max_var)) { -hist_err ("onmax: Couldn't create onmax variable: " ,"max" ); - ret =PTR_ERR (max_var); +if (data->handler ==HANDLER_ONMAX ) + track_var =create_var (hist_data, file,"__max" ,sizeof (u64),"u64" ); +if (IS_ERR (track_var)) { +hist_err ("Couldn't create onmax variable: " ,"__max" ); + ret =PTR_ERR (track_var); goto out; } - data->onmax.max_var = max_var; + data->track_data.track_var = track_var; ret =action_create (hist_data, data); out:
@@ -3570,8 +3636,15 @@ static int action_parse(char *str, struct action_data *data, goto out;if (handler ==HANDLER_ONMAX ) - data->fn = onmax_save; + data->track_data.check_val = check_track_val_max; +else { +hist_err ("action parsing: Handler doesn't support action: " , action_name); + ret = -EINVAL ; + goto out; + } + data->track_data.save_data = save_track_data_vars; + data->fn = ontrack_action; data->action =ACTION_SAVE ; }else {char *params =strsep (&str,")" );
@@ -3582,7 +3655,15 @@ static int action_parse(char *str, struct action_data *data, goto out; } - data->fn = action_trace; +if (handler ==HANDLER_ONMAX ) + data->track_data.check_val = check_track_val_max; + +if (handler !=HANDLER_ONMATCH ) { + data->track_data.save_data = action_trace; + data->fn = ontrack_action; + }else + data->fn = action_trace; + data->action =ACTION_TRACE ; }
@@ -3597,24 +3678,25 @@ static int action_parse(char *str, struct action_data *data,return ret; } -static struct action_data *onmax_parse (char *str,enum handler_id handler) +static struct action_data *track_data_parse (struct hist_trigger_data *hist_data, +char *str,enum handler_id handler) {struct action_data *data; -char *onmax_var_str;int ret = -EINVAL ; +char *var_str; data =kzalloc (sizeof (*data),GFP_KERNEL );if (!data)return ERR_PTR (-ENOMEM ); - onmax_var_str =strsep (&str,")" ); -if (!onmax_var_str || !str) { + var_str =strsep (&str,")" ); +if (!var_str || !str) { ret = -EINVAL ; goto free; } - data->onmax.var_str =kstrdup (onmax_var_str,GFP_KERNEL ); -if (!data->onmax.var_str) { + data->track_data.var_str =kstrdup (var_str,GFP_KERNEL ); +if (!data->track_data.var_str) { ret = -ENOMEM ; goto free; }
@@ -3625,7 +3707,7 @@ static struct action_data *onmax_parse(char *str, enum handler_id handler) out:return data; free: -onmax_destroy (data); +track_data_destroy (hist_data, data); data =ERR_PTR (ret); goto out; }
@@ -4389,7 +4471,7 @@ static void destroy_actions(struct hist_trigger_data *hist_data)if (data->handler ==HANDLER_ONMATCH )onmatch_destroy (data);else if (data->handler ==HANDLER_ONMAX ) -onmax_destroy (data); +track_data_destroy (hist_data, data);else kfree (data); }
@@ -4418,7 +4500,8 @@ static int parse_actions(struct hist_trigger_data *hist_data) }else if ((len =str_has_prefix (str,"onmax(" ))) {char *action_str = str + len; - data =onmax_parse (action_str,HANDLER_ONMAX ); + data =track_data_parse (hist_data, action_str, +HANDLER_ONMAX );if (IS_ERR (data)) { ret =PTR_ERR (data);break ;
@@ -4448,7 +4531,7 @@ static int create_actions(struct hist_trigger_data *hist_data)if (ret)break ; }else if (data->handler ==HANDLER_ONMAX ) { - ret =onmax_create (hist_data, data); + ret =track_data_create (hist_data, data);if (ret)break ; }else {
@@ -4470,7 +4553,7 @@ static void print_actions(struct seq_file *m,struct action_data *data = hist_data->actions[i];if (data->handler ==HANDLER_ONMAX ) -onmax_print (m, hist_data, elt, data); +track_data_print (m, hist_data, elt, data); } }
@@ -4495,12 +4578,13 @@ static void print_action_spec(struct seq_file *m, } } -static void print_onmax_spec (struct seq_file *m, -struct hist_trigger_data *hist_data, -struct action_data *data) +static void print_track_data_spec (struct seq_file *m, +struct hist_trigger_data *hist_data, +struct action_data *data) { -seq_puts (m,":onmax(" ); -seq_printf (m,"%s" , data->onmax.var_str); +if (data->handler ==HANDLER_ONMAX ) +seq_puts (m,":onmax(" ); +seq_printf (m,"%s" , data->track_data.var_str);seq_printf (m,").%s(" , data->action_name);print_action_spec (m, hist_data, data);
@@ -4558,8 +4642,8 @@ static bool actions_match(struct hist_trigger_data *hist_data, data_test->match_data.event) != 0)return false; }else if (data->handler ==HANDLER_ONMAX ) { -if (strcmp (data->onmax.var_str, - data_test->onmax.var_str) !=0 ) +if (strcmp (data->track_data.var_str, + data_test->track_data.var_str) !=0 )return false; } }
@@ -4579,7 +4663,7 @@ static void print_actions_spec(struct seq_file *m,if (data->handler ==HANDLER_ONMATCH )print_onmatch_spec (m, hist_data, data);else if (data->handler ==HANDLER_ONMAX ) -print_onmax_spec (m, hist_data, data); +print_track_data_spec (m, hist_data, data); } }
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 18/29 tracing: Add conditional snapshot
In reply to Steven RostedtFrom: Tom Zanussi <[email protected]>
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.
--- kernel/trace/trace.c | 192 +++++++++++++++++++++++++++++- kernel/trace/trace.h | 56 ++++++++- kernel/trace/trace_sched_wakeup.c | 2 +- 3 files changed, 244 insertions(+), 6 deletions(-)
kernel/trace/trace.c +188 -4
@@ -894,7 +894,7 @@ int __trace_bputs(unsigned long ip, const char *str)EXPORT_SYMBOL_GPL (__trace_bputs);#ifdef CONFIG_TRACER_SNAPSHOT -void tracing_snapshot_instance (struct trace_array *tr) +void tracing_snapshot_instance_cond (struct trace_array *tr,void *cond_data) {struct tracer *tracer = tr->current_trace;unsigned long flags;
@@ -920,10 +920,15 @@ void tracing_snapshot_instance(struct trace_array *tr) }local_irq_save (flags); -update_max_tr (tr, current,smp_processor_id ()); +update_max_tr (tr, current,smp_processor_id (), cond_data);local_irq_restore (flags); } +void tracing_snapshot_instance (struct trace_array *tr) +{ +tracing_snapshot_instance_cond (tr,NULL ); +} +/** * tracing_snapshot - take a snapshot of the current buffer. *
@@ -946,6 +951,54 @@ void tracing_snapshot(void) }EXPORT_SYMBOL_GPL (tracing_snapshot); +/** +* tracing_snapshot_cond - conditionally take a snapshot of the current buffer. +* @tr: The tracing instance to snapshot +* @cond_data: The data to be tested conditionally, and possibly saved +* +* This is the same as tracing_snapshot() except that the snapshot is +* conditional - the snapshot will only happen if the +* cond_snapshot.update() implementation receiving the cond_data +* returns true, which means that the trace array's cond_snapshot +* update() operation used the cond_data to determine whether the +* snapshot should be taken, and if it was, presumably saved it along +* with the snapshot. +*/ +void tracing_snapshot_cond (struct trace_array *tr,void *cond_data) +{ +tracing_snapshot_instance_cond (tr, cond_data); +} +EXPORT_SYMBOL_GPL (tracing_snapshot_cond); + +/** +* tracing_snapshot_cond_data - get the user data associated with a snapshot +* @tr: The tracing instance +* +* When the user enables a conditional snapshot using +* tracing_snapshot_cond_enable(), the user-defined cond_data is saved +* with the snapshot. This accessor is used to retrieve it. +* +* Should not be called from cond_snapshot.update(), since it takes +* the tr->max_lock lock, which the code calling +* cond_snapshot.update() has already done. +* +* Returns the cond_data associated with the trace array's snapshot. +*/ +void *tracing_cond_snapshot_data (struct trace_array *tr) +{ +void *cond_data =NULL ; + +arch_spin_lock (&tr->max_lock); + +if (tr->cond_snapshot) + cond_data = tr->cond_snapshot->cond_data; + +arch_spin_unlock (&tr->max_lock); + +return cond_data; +} +EXPORT_SYMBOL_GPL (tracing_cond_snapshot_data); +static int resize_buffer_duplicate_size (struct trace_buffer *trace_buf,struct trace_buffer *size_buf,int cpu_id);static void set_buffer_entries (struct trace_buffer *buf,unsigned long val);
@@ -1025,12 +1078,103 @@ void tracing_snapshot_alloc(void)tracing_snapshot (); }EXPORT_SYMBOL_GPL (tracing_snapshot_alloc); + +/** +* tracing_snapshot_cond_enable - enable conditional snapshot for an instance +* @tr: The tracing instance +* @cond_data: User data to associate with the snapshot +* @update: Implementation of the cond_snapshot update function +* +* Check whether the conditional snapshot for the given instance has +* already been enabled, or if the current tracer is already using a +* snapshot; if so, return -EBUSY, else create a cond_snapshot and +* save the cond_data and update function inside. +* +* Returns 0 if successful, error otherwise. +*/ +int tracing_snapshot_cond_enable (struct trace_array *tr,void *cond_data, +cond_update_fn_t update) +{ +struct cond_snapshot *cond_snapshot; +int ret =0 ; + + cond_snapshot =kzalloc (sizeof (*cond_snapshot),GFP_KERNEL ); +if (!cond_snapshot) +return -ENOMEM ; + + cond_snapshot->cond_data = cond_data; + cond_snapshot->update = update; + +mutex_lock (&trace_types_lock); + + ret =tracing_alloc_snapshot_instance (tr); +if (ret) + goto fail_unlock; + +if (tr->current_trace->use_max_tr) { + ret = -EBUSY ; + goto fail_unlock; + } + +if (tr->cond_snapshot) { + ret = -EBUSY ; + goto fail_unlock; + } + +arch_spin_lock (&tr->max_lock); + tr->cond_snapshot = cond_snapshot; +arch_spin_unlock (&tr->max_lock); + +mutex_unlock (&trace_types_lock); + +return ret; + + fail_unlock: +mutex_unlock (&trace_types_lock); +kfree (cond_snapshot); +return ret; +} +EXPORT_SYMBOL_GPL (tracing_snapshot_cond_enable); + +/** +* tracing_snapshot_cond_disable - disable conditional snapshot for an instance +* @tr: The tracing instance +* +* Check whether the conditional snapshot for the given instance is +* enabled; if so, free the cond_snapshot associated with it, +* otherwise return -EINVAL. +* +* Returns 0 if successful, error otherwise. +*/ +int tracing_snapshot_cond_disable (struct trace_array *tr) +{ +int ret =0 ; + +arch_spin_lock (&tr->max_lock); + +if (!tr->cond_snapshot) + ret = -EINVAL ; +else { +kfree (tr->cond_snapshot); + tr->cond_snapshot =NULL ; + } + +arch_spin_unlock (&tr->max_lock); + +return ret; +} +EXPORT_SYMBOL_GPL (tracing_snapshot_cond_disable);#else void tracing_snapshot (void ) {WARN_ONCE (1 ,"Snapshot feature not enabled, but internal snapshot used" ); }EXPORT_SYMBOL_GPL (tracing_snapshot); +void tracing_snapshot_cond (struct trace_array *tr,void *cond_data) +{ +WARN_ONCE (1 ,"Snapshot feature not enabled, but internal conditional snapshot used" ); +} +EXPORT_SYMBOL_GPL (tracing_snapshot_cond);int tracing_alloc_snapshot (void ) {WARN_ONCE (1 ,"Snapshot feature not enabled, but snapshot allocation used" );
@@ -1043,6 +1187,21 @@ void tracing_snapshot_alloc(void) tracing_snapshot(); }EXPORT_SYMBOL_GPL (tracing_snapshot_alloc); +void *tracing_cond_snapshot_data (struct trace_array *tr) +{ +return NULL ; +} +EXPORT_SYMBOL_GPL (tracing_cond_snapshot_data); +int tracing_snapshot_cond_enable (struct trace_array *tr,void *cond_data,cond_update_fn_t update) +{ +return -ENODEV ; +} +EXPORT_SYMBOL_GPL (tracing_snapshot_cond_enable); +int tracing_snapshot_cond_disable (struct trace_array *tr) +{ +return false; +} +EXPORT_SYMBOL_GPL (tracing_snapshot_cond_disable);#endif /* CONFIG_TRACER_SNAPSHOT */ void tracer_tracing_off (struct trace_array *tr)
@@ -1354,12 +1513,14 @@ __update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu)* @tr: tracer * @tsk: the task with the latency * @cpu: The cpu that initiated the trace. +* @cond_data: User data associated with a conditional snapshot * * Flip the buffers between the @tr and the max_tr and record information * about which task was the cause of this latency. */ void -update_max_tr (struct trace_array *tr,struct task_struct *tsk,int cpu) +update_max_tr (struct trace_array *tr,struct task_struct *tsk,int cpu, +void *cond_data) {if (tr->stop_count)return ;
@@ -1380,9 +1541,15 @@ update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu)else ring_buffer_record_off (tr->max_buffer.buffer); +#ifdef CONFIG_TRACER_SNAPSHOT +if (tr->cond_snapshot && !tr->cond_snapshot->update (tr, cond_data)) + goto out_unlock; +#endif swap (tr->trace_buffer.buffer, tr->max_buffer.buffer);__update_max_tr (tr, tsk, cpu); + + out_unlock:arch_spin_unlock (&tr->max_lock); }
@@ -5396,6 +5563,16 @@ static int tracing_set_tracer(struct trace_array *tr, const char *buf)if (t == tr->current_trace) goto out; +#ifdef CONFIG_TRACER_SNAPSHOT +if (t->use_max_tr) { +arch_spin_lock (&tr->max_lock); +if (tr->cond_snapshot) + ret = -EBUSY ; +arch_spin_unlock (&tr->max_lock); +if (ret) + goto out; + } +#endif /* Some tracers won't work on kernel command line */ if (system_state <SYSTEM_RUNNING && t->noboot) { pr_warn("Tracer '%s' is not allowed on command line, ignored\n",
@@ -6477,6 +6654,13 @@ tracing_snapshot_write(struct file *filp, const char __user *ubuf, size_t cnt, goto out; } +arch_spin_lock (&tr->max_lock); +if (tr->cond_snapshot) + ret = -EBUSY ; +arch_spin_unlock (&tr->max_lock); +if (ret) + goto out; +switch (val) {case 0 :if (iter->cpu_file !=RING_BUFFER_ALL_CPUS ) {
@@ -6502,7 +6686,7 @@ tracing_snapshot_write(struct file *filp, const char __user *ubuf, size_t cnt,local_irq_disable ();/* Now, we're going to swap */ if (iter->cpu_file ==RING_BUFFER_ALL_CPUS ) -update_max_tr (tr, current,smp_processor_id ()); +update_max_tr (tr, current,smp_processor_id (),NULL );else update_max_tr_single (tr, current, iter->cpu_file);local_irq_enable ();
kernel/trace/trace.h +55 -1
80 lines not on this page · raw message
kernel/trace/trace_sched_wakeup.c +1 -1
@@ -486,7 +486,7 @@ probe_wakeup_sched_switch(void *ignore, bool preempt,if (likely (!is_tracing_stopped ())) { wakeup_trace->max_latency = delta; -update_max_tr (wakeup_trace, wakeup_task, wakeup_cpu); +update_max_tr (wakeup_trace, wakeup_task, wakeup_cpu,NULL ); } out_unlock:
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 19/29 tracing: Add hist trigger snapshot() action
In reply to Steven RostedtFrom: Tom Zanussi <[email protected]>
Add support for hist:handlerXXX($var).snapshot(), which will take a snapshot of the current trace buffer whenever handlerXXX is hit.
As a first user, this also adds snapshot() action support for the onmax() handler i.e. hist:onmax($var).snapshot().
Also, the hist trigger key printing is moved into a separate function so the snapshot() action can print a histogram key outside the histogram display - add and use hist_trigger_print_key() for that purpose.
--- kernel/trace/trace.c | 3 + kernel/trace/trace_events_hist.c | 266 +++++++++++++++++++++++++++++-- 2 files changed, 259 insertions(+), 10 deletions(-)
kernel/trace/trace.c +3 -0
@@ -4919,6 +4919,9 @@ static const char readme_msg[] ="\t The available actions are:\n\n" "\t <synthetic_event>(param list) - generate synthetic event\n" "\t save(field,...) - save current event fields\n" +#ifdef CONFIG_TRACER_SNAPSHOT + "\t snapshot() - snapshot the trace buffer\n" +#endif #endif ;
kernel/trace/trace_events_hist.c +256 -10
347 lines not on this page · raw message
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 20/29 tracing: Add hist trigger snapshot() action Documentation
In reply to Steven RostedtFrom: Tom Zanussi <[email protected]>
Add Documentation for the hist:handlerXXX($var).snapshot() action.
--- Documentation/trace/histogram.rst | 110 ++++++++++++++++++++++++++++++ 1 file changed, 110 insertions(+)
Documentation/trace/histogram.rst +110 -0
@@ -1874,6 +1874,7 @@ The available actions are: - <synthetic_event_name>(param list) - generate synthetic event - save(field,...) - save current event fields + - snapshot() - snapshot the trace buffer The following commonly-used handler.action pairs are available:
@@ -2030,6 +2031,115 @@ The following commonly-used handler.action pairs are available: Entries: 2 Dropped: 0 + - onmax(var).snapshot() + + The 'onmax(var).snapshot()' hist trigger action is invoked + whenever the value of 'var' associated with a histogram entry + exceeds the current maximum contained in that variable. + + The end result is that a global snapshot of the trace buffer will + be saved in the tracing/snapshot file if 'var' exceeds the current + maximum for any hist trigger entry. + + Note that in this case the maximum is a global maximum for the + current trace instance, which is the maximum across all buckets of + the histogram. The key of the specific trace event that caused + the global maximum and the global maximum itself are displayed, + along with a message stating that a snapshot has been taken and + where to find it. The user can use the key information displayed + to locate the corresponding bucket in the histogram for even more + detail. + + As an example the below defines a couple of hist triggers, one for + sched_waking and another for sched_switch, keyed on pid. Whenever + a sched_waking event occurs, the timestamp is saved in the entry + corresponding to the current pid, and when the scheduler switches + back to that pid, the timestamp difference is calculated. If the + resulting latency, stored in wakeup_lat, exceeds the current + maximum latency, a snapshot is taken. As part of the setup, all + the scheduler events are also enabled, which are the events that + will show up in the snapshot when it is taken at some point: + + # echo 1 > /sys/kernel/debug/tracing/events/sched/enable + + # echo 'hist:keys=pid:ts0=common_timestamp.usecs \ + if comm=="cyclictest"' >> \ + /sys/kernel/debug/tracing/events/sched/sched_waking/trigger + + # echo 'hist:keys=next_pid:wakeup_lat=common_timestamp.usecs-$ts0: \ + onmax($wakeup_lat).save(next_prio,next_comm,prev_pid,prev_prio, \ + prev_comm):onmax($wakeup_lat).snapshot() \ + if next_comm=="cyclictest"' >> \ + /sys/kernel/debug/tracing/events/sched/sched_switch/trigger + + When the histogram is displayed, for each bucket the max value + and the saved values corresponding to the max are displayed + following the rest of the fields. + + If a snaphot was taken, there is also a message indicating that, + along with the value and event that triggered the global maximum: + + # cat /sys/kernel/debug/tracing/events/sched/sched_switch/hist + { next_pid: 2101 } hitcount: 200 + max: 52 next_prio: 120 next_comm: cyclictest \ + prev_pid: 0 prev_prio: 120 prev_comm: swapper/6 + + { next_pid: 2103 } hitcount: 1326 + max: 572 next_prio: 19 next_comm: cyclictest \ + prev_pid: 0 prev_prio: 120 prev_comm: swapper/1 + + { next_pid: 2102 } hitcount: 1982 \ + max: 74 next_prio: 19 next_comm: cyclictest \ + prev_pid: 0 prev_prio: 120 prev_comm: swapper/5 + + Snapshot taken (see tracing/snapshot). Details: + triggering value { onmax($wakeup_lat) }: 572 \ + triggered by event with key: { next_pid: 2103 } + + Totals: + Hits: 3508 + Entries: 3 + Dropped: 0 + + In the above case, the event that triggered the global maximum has + the key with next_pid == 2103. If you look at the bucket that has + 2103 as the key, you'll find the additional values save()'d along + with the local maximum for that bucket, which should be the same + as the global maximum (since that was the same value that + triggered the global snapshot). + + And finally, looking at the snapshot data should show at or near + the end the event that triggered the snapshot (in this case you + can verify the timestamps between the sched_waking and + sched_switch events, which should match the time displayed in the + global maximum): + + # cat /sys/kernel/debug/tracing/snapshot + + <...>-2103 [005] d..3 309.873125: sched_switch: prev_comm=cyclictest prev_pid=2103 prev_prio=19 prev_state=D ==> next_comm=swapper/5 next_pid=0 next_prio=120 + <idle>-0 [005] d.h3 309.873611: sched_waking: comm=cyclictest pid=2102 prio=19 target_cpu=005 + <idle>-0 [005] dNh4 309.873613: sched_wakeup: comm=cyclictest pid=2102 prio=19 target_cpu=005 + <idle>-0 [005] d..3 309.873616: sched_switch: prev_comm=swapper/5 prev_pid=0 prev_prio=120 prev_state=S ==> next_comm=cyclictest next_pid=2102 next_prio=19 + <...>-2102 [005] d..3 309.873625: sched_switch: prev_comm=cyclictest prev_pid=2102 prev_prio=19 prev_state=D ==> next_comm=swapper/5 next_pid=0 next_prio=120 + <idle>-0 [005] d.h3 309.874624: sched_waking: comm=cyclictest pid=2102 prio=19 target_cpu=005 + <idle>-0 [005] dNh4 309.874626: sched_wakeup: comm=cyclictest pid=2102 prio=19 target_cpu=005 + <idle>-0 [005] dNh3 309.874628: sched_waking: comm=cyclictest pid=2103 prio=19 target_cpu=005 + <idle>-0 [005] dNh4 309.874630: sched_wakeup: comm=cyclictest pid=2103 prio=19 target_cpu=005 + <idle>-0 [005] d..3 309.874633: sched_switch: prev_comm=swapper/5 prev_pid=0 prev_prio=120 prev_state=S ==> next_comm=cyclictest next_pid=2102 next_prio=19 + <idle>-0 [004] d.h3 309.874757: sched_waking: comm=gnome-terminal- pid=1699 prio=120 target_cpu=004 + <idle>-0 [004] dNh4 309.874762: sched_wakeup: comm=gnome-terminal- pid=1699 prio=120 target_cpu=004 + <idle>-0 [004] d..3 309.874766: sched_switch: prev_comm=swapper/4 prev_pid=0 prev_prio=120 prev_state=S ==> next_comm=gnome-terminal- next_pid=1699 next_prio=120 + gnome-terminal--1699 [004] d.h2 309.874941: sched_stat_runtime: comm=gnome-terminal- pid=1699 runtime=180706 [ns] vruntime=1126870572 [ns] + <idle>-0 [003] d.s4 309.874956: sched_waking: comm=rcu_sched pid=9 prio=120 target_cpu=007 + <idle>-0 [003] d.s5 309.874960: sched_wake_idle_without_ipi: cpu=7 + <idle>-0 [003] d.s5 309.874961: sched_wakeup: comm=rcu_sched pid=9 prio=120 target_cpu=007 + <idle>-0 [007] d..3 309.874963: sched_switch: prev_comm=swapper/7 prev_pid=0 prev_prio=120 prev_state=S ==> next_comm=rcu_sched next_pid=9 next_prio=120 + rcu_sched-9 [007] d..3 309.874973: sched_stat_runtime: comm=rcu_sched pid=9 runtime=13646 [ns] vruntime=22531430286 [ns] + rcu_sched-9 [007] d..3 309.874978: sched_switch: prev_comm=rcu_sched prev_pid=9 prev_prio=120 prev_state=R+ ==> next_comm=swapper/7 next_pid=0 next_prio=120 + <...>-2102 [005] d..4 309.874994: sched_migrate_task: comm=cyclictest pid=2103 prio=19 orig_cpu=5 dest_cpu=1 + <...>-2102 [005] d..4 309.875185: sched_wake_idle_without_ipi: cpu=1 + <idle>-0 [001] d..3 309.875200: sched_switch: prev_comm=swapper/1 prev_pid=0 prev_prio=120 prev_state=S ==> next_comm=cyclictest next_pid=2103 next_prio=19 + 3. User space creating a trigger --------------------------------
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 21/29 tracing: Add hist trigger onchange() handler
In reply to Steven RostedtFrom: Tom Zanussi <[email protected]>
Add support for a hist:onchange($var) handler, similar to the onmax() handler but triggering whenever there's any change in $var, not just a max.
--- kernel/trace/trace.c | 3 +- kernel/trace/trace_events_hist.c | 58 +++++++++++++++++++++++++++----- 2 files changed, 52 insertions(+), 9 deletions(-)
kernel/trace/trace.c +2 -1
@@ -4915,7 +4915,8 @@ static const char readme_msg[] ="\t <handler>.<action>\n\n" "\t The available handlers are:\n\n" "\t onmatch(matching.event) - invoke on addition or update\n" -"\t onmax(var) - invoke if var exceeds current max\n\n" +"\t onmax(var) - invoke if var exceeds current max\n" +"\t onchange(var) - invoke action if var changes\n\n" "\t The available actions are:\n\n" "\t <synthetic_event>(param list) - generate synthetic event\n" "\t save(field,...) - save current event fields\n"
kernel/trace/trace_events_hist.c +50 -8
160 lines not on this page · raw message
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 22/29 tracing: Add hist trigger onchange() handler Documentation
In reply to Steven RostedtFrom: Tom Zanussi <[email protected]>
Add Documentation for the hist:onchange($var) handler.
--- Documentation/trace/histogram.rst | 98 +++++++++++++++++++++++++++++++ 1 file changed, 98 insertions(+)
Documentation/trace/histogram.rst +98 -0
@@ -1869,6 +1869,7 @@ The available handlers are: - onmatch(matching.event) - invoke action on any addition or update - onmax(var) - invoke action if var exceeds current max + - onchange(var) - invoke action if var changes The available actions are:
@@ -2140,6 +2141,103 @@ The following commonly-used handler.action pairs are available: <...>-2102 [005] d..4 309.875185: sched_wake_idle_without_ipi: cpu=1 <idle>-0 [001] d..3 309.875200: sched_switch: prev_comm=swapper/1 prev_pid=0 prev_prio=120 prev_state=S ==> next_comm=cyclictest next_pid=2103 next_prio=19 + - onchange(var).save(field,.. .) + + The 'onchange(var).save(field,...)' hist trigger action is invoked + whenever the value of 'var' associated with a histogram entry + changes. + + The end result is that the trace event fields specified as the + onchange.save() params will be saved if 'var' changes for that + hist trigger entry. This allows context from the event that + changed the value to be saved for later reference. When the + histogram is displayed, additional fields displaying the saved + values will be printed. + + - onchange(var).snapshot() + + The 'onchange(var).snapshot()' hist trigger action is invoked + whenever the value of 'var' associated with a histogram entry + changes. + + The end result is that a global snapshot of the trace buffer will + be saved in the tracing/snapshot file if 'var' changes for any + hist trigger entry. + + Note that in this case the changed value is a global variable + associated withe current trace instance. The key of the specific + trace event that caused the value to change and the global value + itself are displayed, along with a message stating that a snapshot + has been taken and where to find it. The user can use the key + information displayed to locate the corresponding bucket in the + histogram for even more detail. + + As an example the below defines a hist trigger on the tcp_probe + event, keyed on dport. Whenever a tcp_probe event occurs, the + cwnd field is checked against the current value stored in the + $cwnd variable. If the value has changed, a snapshot is taken. + As part of the setup, all the scheduler and tcp events are also + enabled, which are the events that will show up in the snapshot + when it is taken at some point: + + # echo 1 > /sys/kernel/debug/tracing/events/sched/enable + # echo 1 > /sys/kernel/debug/tracing/events/tcp/enable + + # echo 'hist:keys=dport:cwnd=snd_cwnd: \ + onchange($cwnd).save(snd_wnd,srtt,rcv_wnd): \ + onchange($cwnd).snapshot()' >> \ + /sys/kernel/debug/tracing/events/tcp/tcp_probe/trigger + + When the histogram is displayed, for each bucket the tracked value + and the saved values corresponding to that value are displayed + following the rest of the fields. + + If a snaphot was taken, there is also a message indicating that, + along with the value and event that triggered the snapshot: + + # cat /sys/kernel/debug/tracing/events/tcp/tcp_probe/hist + { dport: 1521 } hitcount: 8 + changed: 10 snd_wnd: 35456 srtt: 154262 rcv_wnd: 42112 + + { dport: 80 } hitcount: 23 + changed: 10 snd_wnd: 28960 srtt: 19604 rcv_wnd: 29312 + + { dport: 9001 } hitcount: 172 + changed: 10 snd_wnd: 48384 srtt: 260444 rcv_wnd: 55168 + + { dport: 443 } hitcount: 211 + changed: 10 snd_wnd: 26960 srtt: 17379 rcv_wnd: 28800 + + Snapshot taken (see tracing/snapshot). Details: + triggering value { onchange($cwnd) }: 10 + triggered by event with key: { dport: 80 } + + Totals: + Hits: 414 + Entries: 4 + Dropped: 0 + + In the above case, the event that triggered the snapshot has the + key with dport == 80. If you look at the bucket that has 80 as + the key, you'll find the additional values save()'d along with the + changed value for that bucket, which should be the same as the + global changed value (since that was the same value that triggered + the global snapshot). + + And finally, looking at the snapshot data should show at or near + the end the event that triggered the snapshot: + + # cat /sys/kernel/debug/tracing/snapshot + + gnome-shell-1261 [006] dN.3 49.823113: sched_stat_runtime: comm=gnome-shell pid=1261 runtime=49347 [ns] vruntime=1835730389 [ns] + kworker/u16:4-773 [003] d..3 49.823114: sched_switch: prev_comm=kworker/u16:4 prev_pid=773 prev_prio=120 prev_state=R+ ==> next_comm=kworker/3:2 next_pid=135 next_prio=120 + gnome-shell-1261 [006] d..3 49.823114: sched_switch: prev_comm=gnome-shell prev_pid=1261 prev_prio=120 prev_state=R+ ==> next_comm=kworker/6:2 next_pid=387 next_prio=120 + kworker/3:2-135 [003] d..3 49.823118: sched_stat_runtime: comm=kworker/3:2 pid=135 runtime=5339 [ns] vruntime=17815800388 [ns] + kworker/6:2-387 [006] d..3 49.823120: sched_stat_runtime: comm=kworker/6:2 pid=387 runtime=9594 [ns] vruntime=14589605367 [ns] + kworker/6:2-387 [006] d..3 49.823122: sched_switch: prev_comm=kworker/6:2 prev_pid=387 prev_prio=120 prev_state=R+ ==> next_comm=gnome-shell next_pid=1261 next_prio=120 + kworker/3:2-135 [003] d..3 49.823123: sched_switch: prev_comm=kworker/3:2 prev_pid=135 prev_prio=120 prev_state=T ==> next_comm=swapper/3 next_pid=0 next_prio=120 + <idle>-0 [004] ..s7 49.823798: tcp_probe: src=10.0.0.10:54326 dest=23.215.104.193:80 mark=0x0 length=32 snd_nxt=0xe3ae2ff5 snd_una=0xe3ae2ecd snd_cwnd=10 ssthresh=2147483647 snd_wnd=28960 srtt=19604 rcv_wnd=29312 + 3. User space creating a trigger --------------------------------
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 23/29 tracing: Add alternative synthetic event trace action syntax
In reply to Steven RostedtFrom: Tom Zanussi <[email protected]>
Add a 'trace(synthetic_event_name, params)' alternative to synthetic_event_name(params).
Currently, the syntax used for generating synthetic events is to invoke synthetic_event_name(params) i.e. use the synthetic event name as a function call.
Users requested a new form that more explicitly shows that the synthetic event is in effect being traced. In this version, a new 'trace()' keyword is used, and the synthetic event name is passed in as the first argument.
In addition, for the sake of consistency with other actions, change the documention to emphasize the trace() form over the function-call form, which remains documented as equivalent.
--- Documentation/trace/histogram.rst | 54 +++++++++++++++++++++---------- kernel/trace/trace.c | 2 +- kernel/trace/trace_events_hist.c | 42 +++++++++++++++++++++--- 3 files changed, 76 insertions(+), 22 deletions(-)
Documentation/trace/histogram.rst +37 -17
@@ -1873,31 +1873,45 @@ The available handlers are: The available actions are: - - <synthetic_event_name>(param list) - generate synthetic event + - trace(<synthetic_event_name>,param list) - generate synthetic event - save(field,...) - save current event fields - snapshot() - snapshot the trace buffer The following commonly-used handler.action pairs are available: - - onmatch(matching.event).<synthetic_event_name>(param list) + - onmatch(matching.event).trace(<synthetic_event_name>,param list) - The 'onmatch(matching.event).<synthetic_event_name>(params)' hist - trigger action is invoked whenever an event matches and the - histogram entry would be added or updated. It causes the named - synthetic event to be generated with the values given in the + The 'onmatch(matching.event).trace(<synthetic_event_name>,param + list)' hist trigger action is invoked whenever an event matches + and the histogram entry would be added or updated. It causes the + named synthetic event to be generated with the values given in the 'param list'. The result is the generation of a synthetic event that consists of the values contained in those variables at the - time the invoking event was hit. - - The 'param list' consists of one or more parameters which may be - either variables or fields defined on either the 'matching.event' - or the target event. The variables or fields specified in the - param list may be either fully-qualified or unqualified. If a - variable is specified as unqualified, it must be unique between - the two events. A field name used as a param can be unqualified - if it refers to the target event, but must be fully qualified if - it refers to the matching event. A fully-qualified name is of the - form 'system.event_name.$var_name' or 'system.event_name.field'. + time the invoking event was hit. For example, if the synthetic + event name is 'wakeup_latency', a wakeup_latency event is + generated using onmatch(event).trace(wakeup_latency,arg1,arg2). + + There is also an equivalent alternative form available for + generating synthetic events. In this form, the synthetic event + name is used as if it were a function name. For example, using + the 'wakeup_latency' synthetic event name again, the + wakeup_latency event would be generated by invoking it as if it + were a function call, with the event field values passed in as + arguments: onmatch(event).wakeup_latency(arg1,arg2). The syntax + for this form is: + + onmatch(matching.event).<synthetic_event_name>(param list) + + In either case, the 'param list' consists of one or more + parameters which may be either variables or fields defined on + either the 'matching.event' or the target event. The variables or + fields specified in the param list may be either fully-qualified + or unqualified. If a variable is specified as unqualified, it + must be unique between the two events. A field name used as a + param can be unqualified if it refers to the target event, but + must be fully qualified if it refers to the matching event. A + fully-qualified name is of the form 'system.event_name.$var_name' + or 'system.event_name.field'. The 'matching.event' specification is simply the fully qualified event name of the event that matches the target event for the
@@ -1928,6 +1942,12 @@ The following commonly-used handler.action pairs are available: wakeup_new_test($testpid) if comm=="cyclictest"' >> \ /sys/kernel/debug/tracing/events/sched/sched_wakeup_new/trigger + Or, equivalently, using the 'trace' keyword syntax: + + # echo 'hist:keys=$testpid:testpid=pid:onmatch(sched.sched_wakeup_new).\ + trace(wakeup_new_test,$testpid) if comm=="cyclictest"' >> \ + /sys/kernel/debug/tracing/events/sched/sched_wakeup_new/trigger + Creating and displaying a histogram based on those events is now just a matter of using the fields and new synthetic event in the tracing/events/synthetic directory, as usual::
kernel/trace/trace.c +1 -1
@@ -4918,7 +4918,7 @@ static const char readme_msg[] ="\t onmax(var) - invoke if var exceeds current max\n" "\t onchange(var) - invoke action if var changes\n\n" "\t The available actions are:\n\n" -"\t <synthetic_event>(param list) - generate synthetic event\n" +"\t trace(<synthetic_event>,param list) - generate synthetic event\n" "\t save(field,...) - save current event fields\n" #ifdef CONFIG_TRACER_SNAPSHOT"\t snapshot() - snapshot the trace buffer\n"
kernel/trace/trace_events_hist.c +38 -4
102 lines not on this page · raw message
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 24/29 tracing: Add SPDX license GPL-2.0 license identifier to inter-event testcases
In reply to Steven RostedtFrom: Tom Zanussi <[email protected]>
Apparently this directory was missed in the license cleanup process - add the missing identifiers to the trigger/inter-event test cases.
--- .../test.d/trigger/inter-event/trigger-extended-error-support.tc | 1 + .../test.d/trigger/inter-event/trigger-field-variable-support.tc | 1 + .../trigger/inter-event/trigger-inter-event-combined-hist.tc | 1 + .../test.d/trigger/inter-event/trigger-multi-actions-accept.tc | 1 + .../test.d/trigger/inter-event/trigger-onmatch-action-hist.tc | 1 + .../trigger/inter-event/trigger-onmatch-onmax-action-hist.tc | 1 + .../test.d/trigger/inter-event/trigger-onmax-action-hist.tc | 1 + .../trigger/inter-event/trigger-synthetic-event-createremove.tc | 1 + 8 files changed, 8 insertions(+)
tools/testing/selftests/ftrace/test.d/trigger/inter-event/trigger-extended-error-support.tc +1 -0
@@ -1,4 +1,5 @@ #!/bin/sh +# SPDX-License-Identifier: GPL-2.0 # description: event trigger - test extended error support
tools/testing/selftests/ftrace/test.d/trigger/inter-event/trigger-field-variable-support.tc +1 -0
@@ -1,4 +1,5 @@ #!/bin/sh +# SPDX-License-Identifier: GPL-2.0 # description: event trigger - test field variable support fail() { #msg
tools/testing/selftests/ftrace/test.d/trigger/inter-event/trigger-inter-event-combined-hist.tc +1 -0
@@ -1,4 +1,5 @@ #!/bin/sh +# SPDX-License-Identifier: GPL-2.0 # description: event trigger - test inter-event combined histogram trigger fail() { #msg
tools/testing/selftests/ftrace/test.d/trigger/inter-event/trigger-multi-actions-accept.tc +1 -0
@@ -1,4 +1,5 @@ #!/bin/sh +# SPDX-License-Identifier: GPL-2.0 # description: event trigger - test multiple actions on hist trigger fail() { #msg
tools/testing/selftests/ftrace/test.d/trigger/inter-event/trigger-onmatch-action-hist.tc +1 -0
@@ -1,4 +1,5 @@ #!/bin/sh +# SPDX-License-Identifier: GPL-2.0 # description: event trigger - test inter-event histogram trigger onmatch action fail() { #msg
tools/testing/selftests/ftrace/test.d/trigger/inter-event/trigger-onmatch-onmax-action-hist.tc +1 -0
@@ -1,4 +1,5 @@ #!/bin/sh +# SPDX-License-Identifier: GPL-2.0 # description: event trigger - test inter-event histogram trigger onmatch-onmax action fail() { #msg
tools/testing/selftests/ftrace/test.d/trigger/inter-event/trigger-onmax-action-hist.tc +1 -0
@@ -1,4 +1,5 @@ #!/bin/sh +# SPDX-License-Identifier: GPL-2.0 # description: event trigger - test inter-event histogram trigger onmax action fail() { #msg
tools/testing/selftests/ftrace/test.d/trigger/inter-event/trigger-synthetic-event-createremove.tc +1 -0
@@ -1,4 +1,5 @@ #!/bin/sh +# SPDX-License-Identifier: GPL-2.0 # description: event trigger - test synthetic event create remove fail() { #msg
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 25/29 tracing: Add hist trigger snapshot() action test case
In reply to Steven RostedtFrom: Tom Zanussi <[email protected]>
Add a test case verifying the basic functionality of the hist:snapshot() action.
--- .../trigger-snapshot-action-hist.tc | 43 +++++++++++++++++++ 1 file changed, 43 insertions(+) create mode 100644 tools/testing/selftests/ftrace/test.d/trigger/inter-event/trigger-snapshot-action-hist.tc
tools/testing/selftests/ftrace/test.d/trigger/inter-event/trigger-snapshot-action-hist.tc new file +43 -0
@@ -0,0 +1,43 @@ +#!/bin/sh +# SPDX-License-Identifier: GPL-2.0 +# description: event trigger - test inter-event histogram trigger snapshot action + +fail() { #msg + echo $1 + exit_fail +} + +if [ ! -f set_event ]; then + echo "event tracing is not supported" + exit_unsupported +fi + +if [ ! -f snapshot ]; then + echo "snapshot is not supported" + exit_unsupported +fi + +grep -q "onchange(var)" README || exit_unsupported # version issue + +grep -q "snapshot()" README || exit_unsupported # version issue + +echo "Test snapshot action" + +echo 1 > /sys/kernel/debug/tracing/events/sched/enable + +echo 'hist:keys=comm:newprio=prio:onchange($newprio).save(comm,prio):onchange($newprio).snapshot() if comm=="ping"' >> /sys/kernel/debug/tracing/events/sched/sched_waking/trigger + +ping $LOCALHOST -c 3 +nice -n 1 ping $LOCALHOST -c 3 + +echo 0 > tracing_on + +if ! grep -q "changed:" events/sched/sched_waking/hist; then + fail "Failed to create onchange action inter-event histogram" +fi + +if ! grep -q "comm=ping" snapshot; then + fail "Failed to create snapshot action inter-event histogram" +fi + +exit 0
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 26/29 tracing: Add hist trigger onchange() handler test case
In reply to Steven RostedtFrom: Tom Zanussi <[email protected]>
Add a test case verifying the basic functionality of the hist:onchange($var) handler.
--- .../trigger-onchange-action-hist.tc | 28 +++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 tools/testing/selftests/ftrace/test.d/trigger/inter-event/trigger-onchange-action-hist.tc
tools/testing/selftests/ftrace/test.d/trigger/inter-event/trigger-onchange-action-hist.tc new file +28 -0
@@ -0,0 +1,28 @@ +#!/bin/sh +# SPDX-License-Identifier: GPL-2.0 +# description: event trigger - test inter-event histogram trigger onchange action + +fail() { #msg + echo $1 + exit_fail +} + +if [ ! -f set_event ]; then + echo "event tracing is not supported" + exit_unsupported +fi + +grep -q "onchange(var)" README || exit_unsupported # version issue + +echo "Test onchange action" + +echo 'hist:keys=comm:newprio=prio:onchange($newprio).save(comm,prio) if comm=="ping"' >> /sys/kernel/debug/tracing/events/sched/sched_waking/trigger + +ping $LOCALHOST -c 3 +nice -n 1 ping $LOCALHOST -c 3 + +if ! grep -q "changed:" events/sched/sched_waking/hist; then + fail "Failed to create onchange action inter-event histogram" +fi + +exit 0
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 27/29 tracing: Add alternative synthetic event trace action test case
In reply to Steven RostedtFrom: Tom Zanussi <[email protected]>
Add a test case for the alternative trace(<synthetic_event, params) synthetic event generation syntax.
--- .../inter-event/trigger-trace-action-hist.tc | 42 +++++++++++++++++++ 1 file changed, 42 insertions(+) create mode 100644 tools/testing/selftests/ftrace/test.d/trigger/inter-event/trigger-trace-action-hist.tc
tools/testing/selftests/ftrace/test.d/trigger/inter-event/trigger-trace-action-hist.tc new file +42 -0
@@ -0,0 +1,42 @@ +#!/bin/sh +# SPDX-License-Identifier: GPL-2.0 +# description: event trigger - test inter-event histogram trigger trace action + +fail() { #msg + echo $1 + exit_fail +} + +if [ ! -f set_event ]; then + echo "event tracing is not supported" + exit_unsupported +fi + +if [ ! -f synthetic_events ]; then + echo "synthetic event is not supported" + exit_unsupported +fi + +grep -q "trace(<synthetic_event>" README || exit_unsupported # version issue + +echo "Test create synthetic event" + +echo 'wakeup_latency u64 lat pid_t pid char comm[16]' > synthetic_events +if [ ! -d events/synthetic/wakeup_latency ]; then + fail "Failed to create wakeup_latency synthetic event" +fi + +echo "Test create histogram for synthetic event using trace action" +echo "Test histogram variables,simple expression support and trace action" + +echo 'hist:keys=pid:ts0=common_timestamp.usecs if comm=="ping"' > events/sched/sched_wakeup/trigger +echo 'hist:keys=next_pid:wakeup_lat=common_timestamp.usecs-$ts0:onmatch(sched.sched_wakeup).trace(wakeup_latency,$wakeup_lat,next_pid,next_comm) if next_comm=="ping"' > events/sched/sched_switch/trigger +echo 'hist:keys=comm,pid,lat:wakeup_lat=lat:sort=lat' > events/synthetic/wakeup_latency/trigger + +ping $LOCALHOST -c 5 + +if ! grep -q "ping" events/synthetic/wakeup_latency/hist; then + fail "Failed to create trace action inter-event histogram" +fi + +exit 0
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 28/29 tracing: Add hist trigger action expected fail test case
In reply to Steven RostedtFrom: Tom Zanussi <[email protected]>
Add a test case verifying that basic action combinations fail as expected.
--- .../inter-event/trigger-action-hist-xfail.tc | 30 +++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 tools/testing/selftests/ftrace/test.d/trigger/inter-event/trigger-action-hist-xfail.tc
tools/testing/selftests/ftrace/test.d/trigger/inter-event/trigger-action-hist-xfail.tc new file +30 -0
@@ -0,0 +1,30 @@ +#!/bin/sh +# SPDX-License-Identifier: GPL-2.0 +# description: event trigger - test inter-event histogram trigger expected fail actions + +fail() { #msg + echo $1 + exit_fail +} + +if [ ! -f set_event ]; then + echo "event tracing is not supported" + exit_unsupported +fi + +if [ ! -f snapshot ]; then + echo "snapshot is not supported" + exit_unsupported +fi + +grep -q "snapshot()" README || exit_unsupported # version issue + +echo "Test expected snapshot action failure" + +echo 'hist:keys=comm:onmatch(sched.sched_wakeup).snapshot()' >> /sys/kernel/debug/tracing/events/sched/sched_waking/trigger && exit_fail + +echo "Test expected save action failure" + +echo 'hist:keys=comm:onmatch(sched.sched_wakeup).save(comm,prio)' >> /sys/kernel/debug/tracing/events/sched/sched_waking/trigger && exit_fail + +exit_xfail
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 29/29 tracing: Comment why cond_snapshot is checked outside of max_lock protection
In reply to Steven RostedtFrom: "Steven Rostedt (VMware)" <[email protected]>
Before setting tr->cond_snapshot, it must be NULL before it can be updated. It can go to NULL when a trace event hist trigger is created or removed, and can only be modified under the max_lock spin lock. But because it can only be set to something other than NULL under both the max_lock spin lock as well as the trace_types_lock, we can perform the check if it is not NULL only under the trace_types_lock and fail out without having to grab the max_lock spin lock.
This is very subtle, and deserves a comment.
--- kernel/trace/trace.c | 8 ++++++++ 1 file changed, 8 insertions(+)
kernel/trace/trace.c +8 -0
@@ -1116,6 +1116,14 @@ int tracing_snapshot_cond_enable(struct trace_array *tr, void *cond_data, goto fail_unlock; } +/* +* The cond_snapshot can only change to NULL without the +* trace_types_lock. We don't care if we race with it going +* to NULL, but we want to make sure that it's not set to +* something other than NULL when we get here, which we can +* do safely with only holding the trace_types_lock and not +* having to take the max_lock. +*/ if (tr->cond_snapshot) { ret = -EBUSY ; goto fail_unlock;
Signature · 1 line
2.20.1