tracing: Fixes for 6.13
Subsystems (2)
Steven Rostedt
maintainercover tracing: Fixes for 6.13
Tracing fixes for 6.13:
- Fix a regression in the irqsoff and wakeup latency tracing
The function graph tracer infrastructure has become generic so that kretprobes and BPF can be based on it. As it use to only handle function graph tracing, it would always calculate the time the function entered so that it could then calculate the time it exits and give the length of time the function executed for. But this is not needed for the other users (kretprobes and BPF) and the reading the clock adds a non-negligible overhead, so the calculation was moved into the function graph tracer logic.
But the irqsoff and wakeup latency tracers, when the "display-graph" option was set, would use the function graph tracer to calculate the times of functions during the latency. The movement of the calltime calculation made the value zero for these tracers, and the output no longer showed the length of time of each tracer, but instead the absolute timestamp of when the function returned (rettime - calltime where calltime is zero).
Have the irqsoff and wakeup latency tracers also do the calltime calculation as the function graph tracer does.
- Update the tracing display to reflect the new preempt lazy model
When the system is configured with preempt lazy, the output of the trace data would state "unknown" for the current preemption model. Because the lazy preemption model was just added, make it known to the tracing subsystem too.
git://git.kernel.org/pub/scm/linux/kernel/git/trace/linux-trace.git
trace/fixes
Head SHA1: 24e0e610400aa2c765ee87b1b3c1401732b20fc5
Shrikanth Hegde (1):
tracing: Print lazy preemption model
Steven Rostedt (1):
tracing: Fix irqsoff and wakeup latency tracers when using function graph
----
kernel/trace/trace.c | 1 + kernel/trace/trace_irqsoff.c | 14 ++++++++++++++ kernel/trace/trace_sched_wakeup.c | 14 ++++++++++++++ 3 files changed, 29 insertions(+)
Steven Rostedt
maintainerPATCH 1/2 tracing: Fix irqsoff and wakeup latency tracers when using function graph
From: Steven Rostedt <[email protected]>
The function graph tracer has become generic so that kretprobes and BPF can use it along with function graph tracing itself. Some of the infrastructure was specific for function graph tracing such as recording the calltime and return time of the functions. Calling the clock code on a high volume function does add overhead. The calculation of the calltime was removed from the generic code and placed into the function graph tracer itself so that the other users did not incur this overhead as they did not need that timestamp.
The calltime field was still kept in the generic return entry structure and the function graph return entry callback filled it as that structure was passed to other code.
But this broke both irqsoff and wakeup latency tracer as they still depended on the trace structure containing the calltime when the option display-graph is set as it used some of those same functions that the function graph tracer used. But now the calltime was not set and was just zero. This caused the calculation of the function time to be the absolute value of the return timestamp and not the length of the function.
# cd /sys/kernel/tracing # echo 1 > options/display-graph # echo irqsoff > current_tracer
The tracers went from:
# REL TIME CPU TASK/PID |||| DURATION FUNCTION CALLS
# | | | | |||| | | | | | |
0 us | 4) <idle>-0 | d..1. | 0.000 us | irqentry_enter();
3 us | 4) <idle>-0 | d..2. | | irq_enter_rcu() {
4 us | 4) <idle>-0 | d..2. | 0.431 us | preempt_count_add();
5 us | 4) <idle>-0 | d.h2. | | tick_irq_enter() {
5 us | 4) <idle>-0 | d.h2. | 0.433 us | tick_check_oneshot_broadcast_this_cpu();
6 us | 4) <idle>-0 | d.h2. | 2.426 us | ktime_get();
9 us | 4) <idle>-0 | d.h2. | | tick_nohz_stop_idle() {
10 us | 4) <idle>-0 | d.h2. | 0.398 us | nr_iowait_cpu();
11 us | 4) <idle>-0 | d.h1. | 1.903 us | }
11 us | 4) <idle>-0 | d.h2. | | tick_do_update_jiffies64() {
12 us | 4) <idle>-0 | d.h2. | | _raw_spin_lock() {
12 us | 4) <idle>-0 | d.h2. | 0.360 us | preempt_count_add();
13 us | 4) <idle>-0 | d.h3. | 0.354 us | do_raw_spin_lock();
14 us | 4) <idle>-0 | d.h2. | 2.207 us | }
15 us | 4) <idle>-0 | d.h3. | 0.428 us | calc_global_load();
16 us | 4) <idle>-0 | d.h3. | | _raw_spin_unlock() {
16 us | 4) <idle>-0 | d.h3. | 0.380 us | do_raw_spin_unlock();
17 us | 4) <idle>-0 | d.h3. | 0.334 us | preempt_count_sub();
18 us | 4) <idle>-0 | d.h1. | 1.768 us | }
18 us | 4) <idle>-0 | d.h2. | | update_wall_time() {
[..]To:
# REL TIME CPU TASK/PID |||| DURATION FUNCTION CALLS
# | | | | |||| | | | | | |
0 us | 5) <idle>-0 | d.s2. | 0.000 us | _raw_spin_lock_irqsave();
0 us | 5) <idle>-0 | d.s3. | 312159583 us | preempt_count_add();
2 us | 5) <idle>-0 | d.s4. | 312159585 us | do_raw_spin_lock();
3 us | 5) <idle>-0 | d.s4. | | _raw_spin_unlock() {
3 us | 5) <idle>-0 | d.s4. | 312159586 us | do_raw_spin_unlock();
4 us | 5) <idle>-0 | d.s4. | 312159587 us | preempt_count_sub();
4 us | 5) <idle>-0 | d.s2. | 312159587 us | }
5 us | 5) <idle>-0 | d.s3. | | _raw_spin_lock() {
5 us | 5) <idle>-0 | d.s3. | 312159588 us | preempt_count_add();
6 us | 5) <idle>-0 | d.s4. | 312159589 us | do_raw_spin_lock();
7 us | 5) <idle>-0 | d.s3. | 312159590 us | }
8 us | 5) <idle>-0 | d.s4. | 312159591 us | calc_wheel_index();
9 us | 5) <idle>-0 | d.s4. | | enqueue_timer() {
9 us | 5) <idle>-0 | d.s4. | | wake_up_nohz_cpu() {
11 us | 5) <idle>-0 | d.s4. | | native_smp_send_reschedule() {
11 us | 5) <idle>-0 | d.s4. | 312171987 us | default_send_IPI_single_phys();
12408 us | 5) <idle>-0 | d.s3. | 312171990 us | }
12408 us | 5) <idle>-0 | d.s3. | 312171991 us | }
12409 us | 5) <idle>-0 | d.s3. | 312171991 us | }Where the calculation of the time for each function was the return time minus zero and not the time of when the function returned.
Have these tracers also save the calltime in the fgraph data section and retrieve it again on the return to get the correct timings again.
--- kernel/trace/trace_irqsoff.c | 14 ++++++++++++++ kernel/trace/trace_sched_wakeup.c | 14 ++++++++++++++ 2 files changed, 28 insertions(+)
kernel/trace/trace_irqsoff.c +14 -0
@@ -182,6 +182,7 @@ static int irqsoff_graph_entry(struct ftrace_graph_ent *trace,struct trace_array_cpu *data;unsigned long flags;unsigned int trace_ctx; +u64 *calltime;int ret;if (ftrace_graph_ignore_func (gops, trace))
@@ -199,6 +200,12 @@ static int irqsoff_graph_entry(struct ftrace_graph_ent *trace,if (!func_prolog_dec (tr, &data, &flags))return 0 ; + calltime =fgraph_reserve_data (gops->idx,sizeof (*calltime)); +if (!calltime) +return 0 ; + + *calltime =trace_clock_local (); + trace_ctx =tracing_gen_ctx_flags (flags); ret =__trace_graph_entry (tr, trace, trace_ctx);atomic_dec (&data->disabled);
@@ -213,12 +220,19 @@ static void irqsoff_graph_return(struct ftrace_graph_ret *trace,struct trace_array_cpu *data;unsigned long flags;unsigned int trace_ctx; +u64 *calltime; +int size;ftrace_graph_addr_finish (gops, trace);if (!func_prolog_dec (tr, &data, &flags))return ; + calltime =fgraph_retrieve_data (gops->idx, &size); +if (!calltime) +return ; + trace->calltime = *calltime; + trace_ctx =tracing_gen_ctx_flags (flags);__trace_graph_return (tr, trace, trace_ctx);atomic_dec (&data->disabled);
kernel/trace/trace_sched_wakeup.c +14 -0
@@ -118,6 +118,7 @@ static int wakeup_graph_entry(struct ftrace_graph_ent *trace,struct trace_array *tr = wakeup_trace;struct trace_array_cpu *data;unsigned int trace_ctx; +u64 *calltime;int ret =0 ;if (ftrace_graph_ignore_func (gops, trace))
@@ -135,6 +136,12 @@ static int wakeup_graph_entry(struct ftrace_graph_ent *trace,if (!func_prolog_preempt_disable (tr, &data, &trace_ctx))return 0 ; + calltime =fgraph_reserve_data (gops->idx,sizeof (*calltime)); +if (!calltime) +return 0 ; + + *calltime =trace_clock_local (); + ret =__trace_graph_entry (tr, trace, trace_ctx);atomic_dec (&data->disabled);preempt_enable_notrace ();
@@ -148,12 +155,19 @@ static void wakeup_graph_return(struct ftrace_graph_ret *trace,struct trace_array *tr = wakeup_trace;struct trace_array_cpu *data;unsigned int trace_ctx; +u64 *calltime; +int size;ftrace_graph_addr_finish (gops, trace);if (!func_prolog_preempt_disable (tr, &data, &trace_ctx))return ; + calltime =fgraph_retrieve_data (gops->idx, &size); +if (!calltime) +return ; + trace->calltime = *calltime; +__trace_graph_return (tr, trace, trace_ctx);atomic_dec (&data->disabled);
Signature · 1 line
2.45.2
Steven Rostedt
maintainerPATCH 2/2 tracing: Print lazy preemption model
In reply to Steven RostedtFrom: Shrikanth Hegde <[email protected]>
Print lazy preemption model in ftrace header when latency-format=1.
# cat /sys/kernel/debug/sched/preempt none voluntary full (lazy)
Without patch:
latency: 0 us, #232946/232946, CPU#40 | (M:unknown VP:0, KP:0, SP:0 HP:0 #P:80)
^^^^^^^
With Patch:
latency: 0 us, #1897938/25566788, CPU#16 | (M:lazy VP:0, KP:0, SP:0 HP:0 #P:80)
^^^^
Now that lazy preemption is part of the kernel, make sure the tracing infrastructure reflects that.
--- kernel/trace/trace.c | 1 + 1 file changed, 1 insertion(+)
kernel/trace/trace.c +1 -0
@@ -4122,6 +4122,7 @@ print_trace_header(struct seq_file *m, struct trace_iterator *iter)preempt_model_none () ?"server" :preempt_model_voluntary () ?"desktop" :preempt_model_full () ?"preempt" : +preempt_model_lazy () ?"lazy" :preempt_model_rt () ?"preempt_rt" : "unknown",/* These are reserved for later use */
Signature · 1 line
2.45.2