hwlat improvements and osnoise/timerlat tracers
Subsystems (23)
v3 cover hwlat improvements and osnoise/timerlat tracers
This series proposes a set of improvements and new features for the tracing subsystem to facilitate the debugging of low latency deployments.
Currently, hwlat runs on a single CPU at a time, migrating across a set of CPUs in a round-robin fashion. This series improves hwlat to allow hwlat to run on multiple CPUs in parallel, increasing the chances of detecting a hardware latency, at the cost of using more CPU time.
It also proposes a new tracer named osnoise, that aims to help users of isolcpus= (or a similar method) to measure how much noise the OS and the hardware add to the isolated application. The osnoise tracer bases on the hwlat detector code. The difference is that, instead of sampling with interrupts disabled, the osnoise tracer samples the CPU with interrupts and preemption enabled. In this way, the sampling thread will suffer any source of noise from the OS. The detection and classification of the type of noise are then made by observing the entry points of NMIs, IRQs, SoftIRQs, and threads. If none of these sources of noise is detected, the tool associates the noise with the hardware. The tool periodically prints a status, printing the total noise of the period, the max single noise observed, the percentage of CPU available for the task, along with the counters of each source of the noise. To debug the sources of noise, the tracer also adds a set of tracepoints that print any NMI, IRQ, SofIRQ, and thread occurrence. These tracepoints print the starting time and the noise's net duration at the end of the noise. In this way, it reduces the number of tracepoints (one instead of two) and the need to manually accounting the contribution of each noise independently.
Finaly, the timerlat tracer aims to help the preemptive kernel developers to find sources of wakeup latencies of real-time threads. The tracer creates a per-cpu kernel thread with real-time priority. The tracer thread sets a periodic timer to wakeup itself, and goes to sleep waiting for the timer to fire. At the wakeup, the thread then computes a wakeup latency value as the difference between the current time and the absolute time that the timer was set to expire. The tracer prints two lines at every activation. The first is the timer latency observed at the hardirq context before the activation of the thread. The second is the timer latency observed by the thread, which is the same level that cyclictest reports. The ACTIVATION ID field serves to relate the irq execution to its respective thread execution. The tracer is build on top of osnoise tracer, and the osnoise: events can be used to trace the source of interference from NMI, IRQs and other threads. It also enables the capture of the stacktrace at the IRQ context, which helps to identify the code path that can cause thread delay.
Changes from v2:
- osnoise sample reports in nanoseconds (as all other osnoise tracepoints) (Bristot)
- Remove divisions from osnoise main loop (Bristot)
- Make the tracers work well when starting via kernel-cmdline (Red Hat's performance team need)
- Rename main/interrupt functions (Bristot)
- Fix timerlat reset (Juri Lelli)
- Fix timerlat start (Juri Lelli)
Changes from v1:
- Remove `` from RST (Corbet)
- Add RST files to the index (Corbet)
- Fix text and typos (Rostedt)
- Remove the cpus from hwlat (Rostedt)
- Remove the disable_migrate/fallback to mode none on hwlat (Rostedt)
- Add a generic way to read/write u64 and use it on hwlat/osnoise/timerlat (Rostedt)
- Make osnoise/timerlat to work properly with trace-cmd/tracer instances (Rostedt)
- osnoise using the tracing_threshold (Rostedt)
- Rearrange tracepoint structure to avoid "holes" (Rostedt)
Daniel Bristot de Oliveira (8):
tracing/hwlat: Fix Clark's email
tracing/hwlat: Implement the mode config option tracing/hwlat: Switch disable_migrate to mode none tracing/hwlat: Implement the per-cpu mode
tracing/trace: Add a generic function to read/write u64 values from
tracefs
trace/hwlat: Use the generic function to read/write width and window
tracing: Add osnoise tracer
tracing: Add timerlat tracer
Steven Rostedt (1):
tracing: Add __print_ns_to_secs() and __print_ns_without_secs()
helpers
Documentation/trace/hwlat_detector.rst | 13 +- Documentation/trace/index.rst | 2 + Documentation/trace/osnoise-tracer.rst | 152 ++ Documentation/trace/timerlat-tracer.rst | 158 ++ include/linux/ftrace_irq.h | 13 + include/trace/events/osnoise.h | 142 ++ include/trace/trace_events.h | 25 + kernel/trace/Kconfig | 62 + kernel/trace/Makefile | 1 + kernel/trace/trace.c | 87 + kernel/trace/trace.h | 30 +- kernel/trace/trace_entries.h | 41 + kernel/trace/trace_hwlat.c | 410 +++-- kernel/trace/trace_osnoise.c | 2126 +++++++++++++++++++++++ kernel/trace/trace_output.c | 119 +- 15 files changed, 3234 insertions(+), 147 deletions(-) create mode 100644 Documentation/trace/osnoise-tracer.rst create mode 100644 Documentation/trace/timerlat-tracer.rst create mode 100644 include/trace/events/osnoise.h create mode 100644 kernel/trace/trace_osnoise.c
Signature · 1 line
2.26.3
PATCH v3 1/9 tracing/hwlat: Fix Clark's email
Clark's email is [email protected]
No functional change.
--- kernel/trace/trace_hwlat.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/trace/trace_hwlat.c +1 -1
@@ -34,7 +34,7 @@* Copyright (C) 2008-2009 Jon Masters, Red Hat, Inc. <[email protected]> * Copyright (C) 2013-2016 Steven Rostedt, Red Hat, Inc. <[email protected]> * -* Includes useful feedback from Clark Williams <[email protected]> +* Includes useful feedback from Clark Williams <[email protected]> * */ #include <linux/kthread.h>
Signature · 1 line
2.26.3
PATCH v3 2/9 tracing/hwlat: Implement the mode config option
In reply to Daniel Bristot de OliveiraProvides the "mode" config to the hardware latency detector. hwlatd has two different operation modes. The default mode is the "round-robin" one, in which a single hwlatd thread runs, migrating among the allowed CPUs in a "round-robin" fashion. This is the current behavior.
The "none" sets the allowed cpumask for a single hwlatd thread at the startup, but skips the round-robin, letting the scheduler handle the migration.
In preparation to the per-cpu mode.
--- Documentation/trace/hwlat_detector.rst | 12 +- kernel/trace/trace_hwlat.c | 171 +++++++++++++++++++++++-- 2 files changed, 169 insertions(+), 14 deletions(-)
Documentation/trace/hwlat_detector.rst +8 -4
@@ -76,8 +76,12 @@ in /sys/kernel/tracing: - tracing_cpumask - the CPUs to move the hwlat thread across - hwlat_detector/width - specified amount of time to spin within window (usecs) - hwlat_detector/window - amount of time between (width) runs (usecs) + - hwlat_detector/mode - the thread mode -The hwlat detector's kernel thread will migrate across each CPU specified in -tracing_cpumask between each window. To limit the migration, either modify -tracing_cpumask, or modify the hwlat kernel thread (named [hwlatd]) CPU -affinity directly, and the migration will stop. +By default, the hwlat detector's kernel thread will migrate across each CPU +specified in cpumask at the beginning of a new window, in a round-robin +fashion. This behavior can be changed by changing the thread mode, +the available options are: + + - none: do not force migration + - round-robin: migrate across each CPU specified in cpumask [default]
kernel/trace/trace_hwlat.c +161 -10
230 lines not on this page · raw message
Signature · 1 line
2.26.3
Steven Rostedt
maintainerRe: [PATCH V3 2/9] tracing/hwlat: Implement the mode config option
Quoted 55 lines · On Fri, 14 May 2021 22:51:11 +0200 Daniel Bristot de Oliveira…
Provides the "mode" config to the hardware latency detector. hwlatd has two different operation modes. The default mode is the "round-robin" one, in which a single hwlatd thread runs, migrating among the allowed CPUs in a "round-robin" fashion. This is the current behavior.
The "none" sets the allowed cpumask for a single hwlatd thread at the startup, but skips the round-robin, letting the scheduler handle the migration.
In preparation to the per-cpu mode.
Cc Jonathan Corbet <[email protected]>Cc Steven Rostedt <[email protected]>Cc Ingo Molnar <[email protected]>Cc Peter Zijlstra <[email protected]>Cc Thomas Gleixner <[email protected]>Cc Alexandre Chartre <[email protected]>Cc Clark Willaims <[email protected]>Cc John Kacur <[email protected]>Cc Juri Lelli <[email protected]>Signed-off-by Daniel Bristot de Oliveira <[email protected]>--- Documentation/trace/hwlat_detector.rst | 12 +- kernel/trace/trace_hwlat.c | 171 +++++++++++++++++++++++-- 2 files changed, 169 insertions(+), 14 deletions(-)Documentation/trace/hwlat_detector.rst +8
-4@@ -76,8 +76,12 @@ in /sys/kernel/tracing: - tracing_cpumask - the CPUs to move the hwlat thread across - hwlat_detector/width - specified amount of time to spin within window (usecs) - hwlat_detector/window - amount of time between (width) runs (usecs) + - hwlat_detector/mode - the thread mode -The hwlat detector's kernel thread will migrate across each CPU specified in -tracing_cpumask between each window. To limit the migration, either modify -tracing_cpumask, or modify the hwlat kernel thread (named [hwlatd]) CPU -affinity directly, and the migration will stop. +By default, the hwlat detector's kernel thread will migrate across each CPU +specified in cpumask at the beginning of a new window, in a round-robin +fashion. This behavior can be changed by changing the thread mode, +the available options are: + + - none: do not force migration + - round-robin: migrate across each CPU specified in cpumask [default]kernel/trace/trace_hwlat.c +0
-0@@ -59,6 +59,14 @@ static struct task_struct *hwlat_kthread;
kernel/trace/trace_hwlat.c static struct task_struct *hwlat_kthread; · line 69
Quoted 10 lines
kernel/trace/trace_hwlat.c +8
-0static struct dentry *hwlat_sample_width;/* sample width us */ static struct dentry *hwlat_sample_window;/* sample window us */ +static struct dentry *hwlat_thread_mode;/* hwlat thread mode */ + +enum { +MODE_NONE =0 , +MODE_ROUND_ROBIN , +MODE_MAX +}; +static char *thread_mode_str[] = {"none" ,"round-robin" };
I usually do the above with:
#define HWLAT_MODES \ C(NONE, "none"), \ C(ROUND_ROBIN, "round-robin")
#undef C
#define C(x,y) MODE_##x
enum {
HWLAT_MODES,
MODE_MAX
};
#undef C
#define C(x,y) y
static char *thread_mode_str[] = { HWLAT_MODES };
But this is small enough not to do this.
Quoted 65 lines
kernel/trace/trace_hwlat.c +20
-8/* Save the previous tracing_thresh value */ static unsigned long save_tracing_thresh;@@ -96,11 +104,16 @@ static struct hwlat_data {u64 sample_window;/* total sampling window (on+off) */ u64 sample_width;/* active sampling portion of window */ +int thread_mode;/* thread mode */ + } hwlat_data = { .sample_window = DEFAULT_SAMPLE_WINDOW, .sample_width = DEFAULT_SAMPLE_WIDTH, + .thread_mode =MODE_ROUND_ROBIN }; +static bool hwlat_busy; +static void trace_hwlat_sample (struct hwlat_sample *sample) {struct trace_array *tr = hwlat_trace;@@ -328,7 +341,8 @@ static int kthread_fn(void *data)while (!kthread_should_stop ()) { -move_to_next_cpu (); +if (hwlat_data.thread_mode ==MODE_ROUND_ROBIN ) +move_to_next_cpu ();local_irq_disable ();get_sample ();@@ -366,11 +380,6 @@ static int start_kthread(struct trace_array *tr)if (hwlat_kthread)return 0 ; -/* Just pick the first CPU on first iteration */ -get_online_cpus (); -cpumask_and (current_mask, cpu_online_mask, tr->tracing_cpumask); -put_online_cpus (); - next_cpu =cpumask_first (current_mask); kthread =kthread_create (kthread_fn,NULL ,"hwlatd" );if (IS_ERR (kthread)) {@@ -378,8 +387,19 @@ static int start_kthread(struct trace_array *tr)return -ENOMEM ; } -cpumask_clear (current_mask); -cpumask_set_cpu (next_cpu, current_mask); + +/* Just pick the first CPU on first iteration */ +get_online_cpus (); +cpumask_and (current_mask, cpu_online_mask, tr->tracing_cpumask); +put_online_cpus (); + +if (hwlat_data.thread_mode ==MODE_ROUND_ROBIN ) { + next_cpu =cpumask_first (current_mask); +cpumask_clear (current_mask); +cpumask_set_cpu (next_cpu, current_mask); + + } +sched_setaffinity (kthread->pid, current_mask); hwlat_kthread = kthread;
kernel/trace/trace_hwlat.c hwlat_window_write(struct file *filp, const char __user *ubuf, · line 537
Quoted 7 lines
kernel/trace/trace_hwlat.c +4
-0@@ -511,6 +531,125 @@ hwlat_window_write(struct file *filp, const char __user *ubuf,return cnt; } +static void *s_mode_start (struct seq_file *s,loff_t *pos) +{ +int mode = *pos; +
Probably should add:
mutex_lock(&hwlat_data.lock);
here.
Quoted 25 lines
kernel/trace/trace_hwlat.c +25
-0+if (mode >=MODE_MAX ) +return NULL ; + +return pos; +} + +static void *s_mode_next (struct seq_file *s,void *v,loff_t *pos) +{ +int mode = ++(*pos); + +if (mode >=MODE_MAX ) +return NULL ; + +return pos; +} + +static int s_mode_show (struct seq_file *s,void *v) +{ +loff_t *pos = v; +int mode = *pos; + +if (mode == hwlat_data.thread_mode) +seq_printf (s,"[%s]" , thread_mode_str[mode]); +else +seq_printf (s,"%s" , thread_mode_str[mode]);
kernel/trace/trace_hwlat.c hwlat_window_write(struct file *filp, const char __user *ubuf, · line 572
Quoted 10 lines
kernel/trace/trace_hwlat.c +10
-0+ +if (mode !=MODE_MAX ) +seq_puts (s," " ); + +return 0 ; +} + +static void s_mode_stop (struct seq_file *s,void *v) +{ +seq_puts (s,"\n" );
And
mutex_unlock(&hwlat_data.lock);
here to prevent conflicts with the update?
Quoted 6 lines
kernel/trace/trace_hwlat.c +6
-0+} + +static const struct seq_operations thread_mode_seq_ops = { + .start = s_mode_start, + .next = s_mode_next, + .show = s_mode_show,
kernel/trace/trace_hwlat.c hwlat_window_write(struct file *filp, const char __user *ubuf, · line 588
Quoted 10 lines
kernel/trace/trace_hwlat.c +10
-0+ .stop = s_mode_stop +}; + +static int hwlat_mode_open (struct inode *inode,struct file *file) +{ +return seq_open (file, &thread_mode_seq_ops); +}; + +static void hwlat_tracer_start (struct trace_array *tr); +static void hwlat_tracer_stop (struct trace_array *tr);
Add newline here.
Quoted 96 lines
kernel/trace/trace_hwlat.c +78
-0+/** +* hwlat_mode_write - Write function for "mode" entry +* @filp: The active open file structure +* @ubuf: The user buffer that contains the value to write +* @cnt: The maximum number of bytes to write to "file" +* @ppos: The current position in @file +* +* This function provides a write implementation for the "mode" interface +* to the hardware latency detector. hwlatd has different operation modes. +* The "none" sets the allowed cpumask for a single hwlatd thread at the +* startup and lets the scheduler handle the migration. The default mode is +* the "round-robin" one, in which a single hwlatd thread runs, migrating +* among the allowed CPUs in a round-robin fashion. +*/ +static ssize_t hwlat_mode_write (struct file *filp,const char __user *ubuf, +size_t cnt,loff_t *ppos) +{ +struct trace_array *tr = hwlat_trace; +const char *mode; +char buf[64 ]; +int ret, i; + +if (cnt >=sizeof (buf)) +return -EINVAL ; + +if (copy_from_user (buf, ubuf, cnt)) +return -EFAULT ; + + buf[cnt] =0 ; + + mode =strstrip (buf); + + ret = -EINVAL ; + +/* +* trace_types_lock is taken to avoid concurrency on start/stop +* and hwlat_busy. +*/ +mutex_lock (&trace_types_lock); +if (hwlat_busy) +hwlat_tracer_stop (tr); + +mutex_lock (&hwlat_data.lock); + +for (i =0 ; i <MODE_MAX ; i++) { +if (strcmp (mode, thread_mode_str[i]) ==0 ) { + hwlat_data.thread_mode = i; + ret = cnt; + } + } + +mutex_unlock (&hwlat_data.lock); + +if (hwlat_busy) +hwlat_tracer_start (tr); +mutex_unlock (&trace_types_lock); + + *ppos += cnt; + + + +return ret; +} +static const struct file_operations width_fops = { .open = tracing_open_generic, .read = hwlat_read,@@ -523,6 +662,13 @@ static const struct file_operations window_fops = { .write = hwlat_window_write, }; +static const struct file_operations thread_mode_fops = { + .open = hwlat_mode_open, + .read = seq_read, + .llseek = seq_lseek, + .release = seq_release, + .write = hwlat_mode_write +};/** * init_tracefs - A function to initialize the tracefs interface files * @@ -558,6 +704,13 @@ static int init_tracefs(void)if (!hwlat_sample_width) goto err; + hwlat_thread_mode =trace_create_file ("mode" ,0644 , + top_dir, +NULL , + &thread_mode_fops); +if (!hwlat_thread_mode) + goto err; +return 0 ; err:
kernel/trace/trace_hwlat.c static void hwlat_tracer_stop(struct trace_array *tr) · line 737
Quoted 8 lines
kernel/trace/trace_hwlat.c +0
-2@@ -579,8 +732,6 @@ static void hwlat_tracer_stop(struct trace_array *tr)stop_kthread (); } -static bool hwlat_busy; -static int hwlat_tracer_init (struct trace_array *tr) {/* Only allow one instance to enable this */
-- Steve
PATCH v3 3/9 tracing/hwlat: Switch disable_migrate to mode none
In reply to Daniel Bristot de OliveiraWhen in the round-robin mode, if the tracer detects a change in the hwlatd thread affinity by an external tool, e.g., taskset, the round-robin logic is disabled. The disable_migrate variable currently tracks this.
With the addition of the "mode" config and the mode "none," the disable_migrate logic is equivalent to switch to the "none" mode.
Hence, instead of using a hidden variable to track this behavior, switch the mode to none, informing the user about this change.
--- kernel/trace/trace_hwlat.c | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-)
kernel/trace/trace_hwlat.c +5 -8
@@ -286,7 +286,6 @@ static int get_sample(void) }static struct cpumask save_cpumask; -static bool disable_migrate;static void move_to_next_cpu (void ) {
@@ -294,15 +293,13 @@ static void move_to_next_cpu(void)struct trace_array *tr = hwlat_trace;int next_cpu; -if (disable_migrate) -return ;/* * If for some reason the user modifies the CPU affinity * of this thread, then stop migrating for the duration * of the current test. */ if (!cpumask_equal (current_mask, current->cpus_ptr)) - goto disable; + goto change_mode;get_online_cpus ();cpumask_and (current_mask, cpu_online_mask, tr->tracing_cpumask);
@@ -313,7 +310,7 @@ static void move_to_next_cpu(void) next_cpu =cpumask_first (current_mask);if (next_cpu >= nr_cpu_ids)/* Shouldn't happen! */ - goto disable; + goto change_mode;cpumask_clear (current_mask);cpumask_set_cpu (next_cpu, current_mask);
@@ -321,8 +318,9 @@ static void move_to_next_cpu(void)sched_setaffinity (0 , current_mask);return ; - disable: - disable_migrate = true; + change_mode: + hwlat_data.thread_mode =MODE_NONE ; +pr_info (BANNER "cpumask changed while in round-robin mode, switching to mode none\n" ); }/*
@@ -740,7 +738,6 @@ static int hwlat_tracer_init(struct trace_array *tr) hwlat_trace = tr; - disable_migrate = false; hwlat_data.count =0 ; tr->max_latency =0 ; save_tracing_thresh = tracing_thresh;
Signature · 1 line
2.26.3
PATCH v3 4/9 tracing/hwlat: Implement the per-cpu mode
In reply to Daniel Bristot de OliveiraImplements the per-cpu mode in which a sampling thread is created for each cpu in the "cpus" (and tracing_mask).
The per-cpu mode has the potention to speed up the hwlat detection by running on multiple CPUs at the same time, at the cost of higher cpu usage with irqs disabled. Use with care.
--- Documentation/trace/hwlat_detector.rst | 3 +- kernel/trace/trace_hwlat.c | 165 +++++++++++++++++++------ 2 files changed, 130 insertions(+), 38 deletions(-)
Documentation/trace/hwlat_detector.rst +2 -1
@@ -78,10 +78,11 @@ in /sys/kernel/tracing: - hwlat_detector/window - amount of time between (width) runs (usecs) - hwlat_detector/mode - the thread mode -By default, the hwlat detector's kernel thread will migrate across each CPU +By default, one hwlat detector kernel thread will migrate across each CPU specified in cpumask at the beginning of a new window, in a round-robin fashion. This behavior can be changed by changing the thread mode, the available options are: - none: do not force migration - round-robin: migrate across each CPU specified in cpumask [default] + - per-cpu: create one thread for each cpu in tracing_cpumask
kernel/trace/trace_hwlat.c +128 -37
286 lines not on this page · raw message
Signature · 1 line
2.26.3
Re: [PATCH V3 4/9] tracing/hwlat: Implement the per-cpu mode
Hi,
On 14/05/21 22:51, Daniel Bristot de Oliveira wrote:
[...]
Quoted 7 lines
kernel/trace/trace_hwlat.c +7
-0+/** +* start_per_cpu_kthread - Kick off the hardware latency sampling/detector kthreads +* +* This starts the kernel threads that will sit on potentially all cpus and +* sample the CPU timestamp counter (TSC or similar) and look for potential +* hardware latencies. +*/
kernel/trace/trace_hwlat.c static int start_kthread(struct trace_array *tr) · line 478
Quoted 10 lines
kernel/trace/trace_hwlat.c +10
-0+static int start_per_cpu_kthreads (struct trace_array *tr) +{ +struct cpumask *current_mask = &save_cpumask; +struct cpumask *this_cpumask; +struct task_struct *kthread; +char comm[24 ]; +int cpu; + +if (!alloc_cpumask_var (&this_cpumask,GFP_KERNEL )) +return -ENOMEM ;
Is this_cpumask actually used anywhere?
Thanks,
Juri
Re: [PATCH V3 4/9] tracing/hwlat: Implement the per-cpu mode
Quoted 17 lines · Juri Lelli
Hi,
On 14/05/21 22:51, Daniel Bristot de Oliveira wrote:
[...]
Quoted 11 lines
kernel/trace/trace_hwlat.c +11
-0+/** +* start_per_cpu_kthread - Kick off the hardware latency sampling/detector kthreads +* +* This starts the kernel threads that will sit on potentially all cpus and +* sample the CPU timestamp counter (TSC or similar) and look for potential +* hardware latencies. +*/ +static int start_per_cpu_kthreads (struct trace_array *tr) +{ +struct cpumask *current_mask = &save_cpumask; +struct cpumask *this_cpumask;
Quoted 8 lines
kernel/trace/trace_hwlat.c static int start_kthread(struct trace_array *tr) · line 478
Quoted 6 lines
kernel/trace/trace_hwlat.c +6
-0+struct task_struct *kthread; +char comm[24 ]; +int cpu; + +if (!alloc_cpumask_var (&this_cpumask,GFP_KERNEL )) +return -ENOMEM ;Is
this_cpumaskactually used anywhere?
OOpppsss, this is a left-over :-(....
Before starting using kthread_create_on_cpu(), I was using this_cpumask to set the affinity of threads created via kthread_create().... but it is not needed anymore.
I will remove it, good catch.
Thanks!
-- Daniel
Quoted 4 lines
Thanks,
Juri
Steven Rostedt
maintainerRe: [PATCH V3 4/9] tracing/hwlat: Implement the per-cpu mode
In reply to Daniel Bristot de Oliveirakernel/trace/trace_hwlat.c static void trace_hwlat_sample(struct hwlat_sample *sample) · line 167
Quoted 6 lines · On Fri, 14 May 2021 22:51:13 +0200 Daniel Bristot de Oliveira…
void
trace_hwlat_callback(bool enter)
{kernel/trace/trace_hwlat.c +3
-1-if (smp_processor_id () != nmi_cpu) +struct hwlat_kthread_data *kdata =get_cpu_data (); + +if (kdata->kthread)
Shouldn't that be:
if (!kdata->kthread)
?
-- Steve
Quoted 19 lines
kernel/trace/trace_hwlat.c +3
-3return ;/* @@ -158,13 +173,13 @@ void trace_hwlat_callback(bool enter)*/ if (!IS_ENABLED (CONFIG_GENERIC_SCHED_CLOCK )) {if (enter) - nmi_ts_start =time_get (); + kdata->nmi_ts_start =time_get ();else - nmi_total_ts +=time_get () - nmi_ts_start; + kdata->nmi_total_ts +=time_get () - kdata->nmi_ts_start; }if (enter) - nmi_count++; + kdata->nmi_count++; }
Re: [PATCH V3 4/9] tracing/hwlat: Implement the per-cpu mode
Quoted 12 lines · Steven Rostedt
kernel/trace/trace_hwlat.c static void trace_hwlat_sample(struct hwlat_sample *sample) · line 167
Quoted 6 lines · On Fri, 14 May 2021 22:51:13 +0200 Daniel Bristot de Oliveira…
void
trace_hwlat_callback(bool enter)
{kernel/trace/trace_hwlat.c +3
-1-if (smp_processor_id () != nmi_cpu) +struct hwlat_kthread_data *kdata =get_cpu_data (); + +if (kdata->kthread)Shouldn't that be:
Quoted 1 line
if (!kdata->kthread)
oops! Fixing in v4.
-- Daniel
Quoted 24 lines
?
-- Steve
Quoted 19 lines
kernel/trace/trace_hwlat.c +3
-3return ;/* @@ -158,13 +173,13 @@ void trace_hwlat_callback(bool enter)*/ if (!IS_ENABLED (CONFIG_GENERIC_SCHED_CLOCK )) {if (enter) - nmi_ts_start =time_get (); + kdata->nmi_ts_start =time_get ();else - nmi_total_ts +=time_get () - nmi_ts_start; + kdata->nmi_total_ts +=time_get () - kdata->nmi_ts_start; }if (enter) - nmi_count++; + kdata->nmi_count++; }
PATCH v3 5/9 tracing/trace: Add a generic function to read/write u64 values from tracefs
In reply to Daniel Bristot de OliveiraProvides a generic read and write implementation to save/read u64 values from a file on tracefs. The trace_ull_config structure defines where to read/write the value, the min and the max acceptable values, and a lock to protect the write.
--- kernel/trace/trace.c | 87 ++++++++++++++++++++++++++++++++++++++++++++ kernel/trace/trace.h | 19 ++++++++++ 2 files changed, 106 insertions(+)
kernel/trace/trace.c +87 -0
@@ -7516,6 +7516,93 @@ static const struct file_operations snapshot_raw_fops = {#endif /* CONFIG_TRACER_SNAPSHOT */ +/* +* trace_ull_config_write - Generic write function to save u64 value +* @filp: The active open file structure +* @ubuf: The userspace provided buffer to read value into +* @cnt: The maximum number of bytes to read +* @ppos: The current "file" position +* +* This function provides a generic write implementation to save u64 values +* from a file on tracefs. The filp->private_data must point to a +* trace_ull_config structure that defines where to write the value, the +* min and the max acceptable values, and a lock to protect the write. +*/ +static ssize_t +trace_ull_config_write (struct file *filp,const char __user *ubuf,size_t cnt, +loff_t *ppos) +{ +struct trace_ull_config *config = filp->private_data; +u64 val; +int err; + +if (!config) +return -EFAULT ; + + err =kstrtoull_from_user (ubuf, cnt,10 , &val); +if (err) +return err; + +if (config->lock) +mutex_lock (config->lock); + +if (config->min && val < *config->min) + err = -EINVAL ; + +if (config->max && val > *config->max) + err = -EINVAL ; + +if (!err) + *config->val = val; + +if (config->lock) +mutex_unlock (config->lock); + +if (err) +return err; + +return cnt; +} + +/* +* trace_ull_config_read - Generic write function to read u64 value via tracefs +* @filp: The active open file structure +* @ubuf: The userspace provided buffer to read value into +* @cnt: The maximum number of bytes to read +* @ppos: The current "file" position +* +* This function provides a generic read implementation to read a u64 value +* from a file on tracefs. The filp->private_data must point to a +* trace_ull_config structure with valid data. +*/ +static ssize_t +trace_ull_config_read (struct file *filp,char __user *ubuf,size_t cnt, +loff_t *ppos) +{ +struct trace_ull_config *config = filp->private_data; +char buf[ULL_STR_SIZE ]; +u64 val; +int len; + +if (!config) +return -EFAULT ; + + val = *config->val; + +if (cnt >sizeof (buf)) + cnt =sizeof (buf); + + len =snprintf (buf,sizeof (buf),"%llu\n" , val); + +return simple_read_from_buffer (ubuf, cnt, ppos, buf, len); +} + +const struct file_operations trace_ull_config_fops = { + .open = tracing_open_generic, + .read = trace_ull_config_read, + .write = trace_ull_config_write, +}; +#define TRACING_LOG_ERRS_MAX 8#define TRACING_LOG_LOC_MAX 128
kernel/trace/trace.h +19 -0
@@ -1952,4 +1952,23 @@ static inline bool is_good_name(const char *name) return true; } +/* +* This is a generic way to read and write a u64 config value from a file +* in tracefs. +* +* The value is stored on the variable pointed by *val. The value needs +* to be at least *min and at most *max. The write is protected by an +* existing *lock. +*/ +struct trace_ull_config { +struct mutex *lock; +u64 *val; +u64 *min; +u64 *max; +}; + +#define ULL_STR_SIZE 22/* 20 digits max */ + +extern const struct file_operations trace_ull_config_fops; +#endif /* _LINUX_KERNEL_TRACE_H */
Signature · 1 line
2.26.3
Steven Rostedt
maintainerRe: [PATCH V3 5/9] tracing/trace: Add a generic function to read/write u64 values from tracefs
Quoted 4 lines · On Fri, 14 May 2021 22:51:14 +0200 Daniel Bristot de Oliveira…
Provides a generic read and write implementation to save/read u64 values from a file on tracefs. The
trace_ull_configstructure defines where to read/write the value, the min and the max acceptable values, and a lock to protect the write.
This states what the patch is doing, but does not say why it is doing it.
Quoted 23 lines
Cc Jonathan Corbet <[email protected]>Cc Steven Rostedt <[email protected]>Cc Ingo Molnar <[email protected]>Cc Peter Zijlstra <[email protected]>Cc Thomas Gleixner <[email protected]>Cc Alexandre Chartre <[email protected]>Cc Clark Willaims <[email protected]>Cc John Kacur <[email protected]>Cc Juri Lelli <[email protected]>Signed-off-by Daniel Bristot de Oliveira <[email protected]>--- kernel/trace/trace.c | 87 ++++++++++++++++++++++++++++++++++++++++++++ kernel/trace/trace.h | 19 ++++++++++ 2 files changed, 106 insertions(+)kernel/trace/trace.c +0
-0
kernel/trace/trace.c static const struct file_operations snapshot_raw_fops = { · line 7520
Quoted 5 lines
kernel/trace/trace.c +2
-0@@ -7516,6 +7516,93 @@ static const struct file_operations snapshot_raw_fops = {#endif /* CONFIG_TRACER_SNAPSHOT */ +/* +* trace_ull_config_write - Generic write function to save u64 value
That is a horrible name. What the hell is the "config"?
kernel/trace/trace.c static const struct file_operations snapshot_raw_fops = { · line 7529
Quoted 9 lines
kernel/trace/trace.c +9
-0+* @filp: The active open file structure +* @ubuf: The userspace provided buffer to read value into +* @cnt: The maximum number of bytes to read +* @ppos: The current "file" position +* +* This function provides a generic write implementation to save u64 values +* from a file on tracefs. The filp->private_data must point to a +* trace_ull_config structure that defines where to write the value, the +* min and the max acceptable values, and a lock to protect the write.
This doesn't seem to be a generic way to save 64 bit values (which I still don't understand, because unsigned long long should work too). But it looks like the rational is for having some kind of generic way to read 64 bit values giving them a min and a max.
I see this is used later, but this patch needs to be rewritten. It makes no sense.
-- Steve
Quoted 107 lines
kernel/trace/trace.c +76
-0+*/ +static ssize_t +trace_ull_config_write (struct file *filp,const char __user *ubuf,size_t cnt, +loff_t *ppos) +{ +struct trace_ull_config *config = filp->private_data; +u64 val; +int err; + +if (!config) +return -EFAULT ; + + err =kstrtoull_from_user (ubuf, cnt,10 , &val); +if (err) +return err; + +if (config->lock) +mutex_lock (config->lock); + +if (config->min && val < *config->min) + err = -EINVAL ; + +if (config->max && val > *config->max) + err = -EINVAL ; + +if (!err) + *config->val = val; + +if (config->lock) +mutex_unlock (config->lock); + +if (err) +return err; + +return cnt; +} + +/* +* trace_ull_config_read - Generic write function to read u64 value via tracefs +* @filp: The active open file structure +* @ubuf: The userspace provided buffer to read value into +* @cnt: The maximum number of bytes to read +* @ppos: The current "file" position +* +* This function provides a generic read implementation to read a u64 value +* from a file on tracefs. The filp->private_data must point to a +* trace_ull_config structure with valid data. +*/ +static ssize_t +trace_ull_config_read (struct file *filp,char __user *ubuf,size_t cnt, +loff_t *ppos) +{ +struct trace_ull_config *config = filp->private_data; +char buf[ULL_STR_SIZE ]; +u64 val; +int len; + +if (!config) +return -EFAULT ; + + val = *config->val; + +if (cnt >sizeof (buf)) + cnt =sizeof (buf); + + len =snprintf (buf,sizeof (buf),"%llu\n" , val); + +return simple_read_from_buffer (ubuf, cnt, ppos, buf, len); +} + +const struct file_operations trace_ull_config_fops = { + .open = tracing_open_generic, + .read = trace_ull_config_read, + .write = trace_ull_config_write, +}; +#define TRACING_LOG_ERRS_MAX 8#define TRACING_LOG_LOC_MAX 128kernel/trace/trace.h +19
-0@@ -1952,4 +1952,23 @@ static inline bool is_good_name(const char *name) return true; } +/* +* This is a generic way to read and write a u64 config value from a file +* in tracefs. +* +* The value is stored on the variable pointed by *val. The value needs +* to be at least *min and at most *max. The write is protected by an +* existing *lock. +*/ +struct trace_ull_config { +struct mutex *lock; +u64 *val; +u64 *min; +u64 *max; +}; + +#define ULL_STR_SIZE 22/* 20 digits max */ + +extern const struct file_operations trace_ull_config_fops; +#endif /* _LINUX_KERNEL_TRACE_H */
Re: [PATCH V3 5/9] tracing/trace: Add a generic function to read/write u64 values from tracefs
Quoted 9 lines · Steven Rostedt
Quoted 4 lines · On Fri, 14 May 2021 22:51:14 +0200 Daniel Bristot de Oliveira…
Provides a generic read and write implementation to save/read u64 values from a file on tracefs. The
trace_ull_configstructure defines where to read/write the value, the min and the max acceptable values, and a lock to protect the write.This states what the patch is doing, but does not say why it is doing it.
Yeah...
Quoted 42 lines
Quoted 23 lines
Cc Jonathan Corbet <[email protected]>Cc Steven Rostedt <[email protected]>Cc Ingo Molnar <[email protected]>Cc Peter Zijlstra <[email protected]>Cc Thomas Gleixner <[email protected]>Cc Alexandre Chartre <[email protected]>Cc Clark Willaims <[email protected]>Cc John Kacur <[email protected]>Cc Juri Lelli <[email protected]>Signed-off-by Daniel Bristot de Oliveira <[email protected]>--- kernel/trace/trace.c | 87 ++++++++++++++++++++++++++++++++++++++++++++ kernel/trace/trace.h | 19 ++++++++++ 2 files changed, 106 insertions(+)kernel/trace/trace.c +0
-0kernel/trace/trace.c static const struct file_operations snapshot_raw_fops = { · line 7520
Quoted 5 lines
kernel/trace/trace.c +2
-0@@ -7516,6 +7516,93 @@ static const struct file_operations snapshot_raw_fops = {#endif /* CONFIG_TRACER_SNAPSHOT */ +/* +* trace_ull_config_write - Generic write function to save u64 value That is a horrible name. What the hell is the "config"?
kernel/trace/trace.c static const struct file_operations snapshot_raw_fops = { · line 7529
Quoted 9 lines
kernel/trace/trace.c +9
-0+* @filp: The active open file structure +* @ubuf: The userspace provided buffer to read value into +* @cnt: The maximum number of bytes to read +* @ppos: The current "file" position +* +* This function provides a generic write implementation to save u64 values +* from a file on tracefs. The filp->private_data must point to a +* trace_ull_config structure that defines where to write the value, the +* min and the max acceptable values, and a lock to protect the write.
Quoted 7 lines
This doesn't seem to be a generic way to save 64 bit values (which I still don't understand, because unsigned long long should work too). But it looks like the rational is for having some kind of generic way to read 64 bit values giving them a min and a max.
I see this is used later, but this patch needs to be rewritten. It makes no sense.
The reason for this patch is that hwlat, osnoise, and timerlat have "u64 config" options that are read/write via tracefs "files." In the previous version, I had multiple functions doing basically the same thing:
A write function that:
read a u64 from user-space
get a lock,
check for min/max acceptable values
save the value
release the lock.
and a read function that:
write the config value to the "read" buffer.
And so, I tried to come up with a way to avoid code duplication.
question: are only the names that are bad? (I agree that they are bad) or do you think that the overall idea is bad? :-)
Suggestions?
-- Daniel
Quoted 1 line
-- Steve
Steven Rostedt
maintainerRe: [PATCH V3 5/9] tracing/trace: Add a generic function to read/write u64 values from tracefs
Quoted 15 lines · On Fri, 4 Jun 2021 18:05:06 +0200 Daniel Bristot de Oliveira…
The reason for this patch is that hwlat, osnoise, and timerlat have "u64 config" options that are read/write via tracefs "files." In the previous version, I had multiple functions doing basically the same thing:
A write function that:
read a u64 from user-space
get a lock,
check for min/max acceptable values
save the value
release the lock.and a read function that:
write the config value to the "read" buffer.
Quoted 6 lines
And so, I tried to come up with a way to avoid code duplication.
question: are only the names that are bad? (I agree that they are bad) or do you think that the overall idea is bad? :-)
Suggestions?
I don't think the overall idea is bad, if it is what I think you are doing. I just don't believe you articulated what you are doing.
It has nothing to do with 64 bit reads and writes, but instead has to do with reading and writing values that depend on each other for what is acceptable.
Perhaps have it called trace_min_max_write() and trace_min_max_read(), and document what it is used for.
-- Steve
Re: [PATCH V3 5/9] tracing/trace: Add a generic function to read/write u64 values from tracefs
Quoted 20 lines · Steven Rostedt
Quoted 17 lines · On Fri, 4 Jun 2021 18:05:06 +0200 Daniel Bristot de Oliveira…
The reason for this patch is that hwlat, osnoise, and timerlat have "u64 config" options that are read/write via tracefs "files." In the previous version, I had multiple functions doing basically the same thing:
A write function that:
read a u64 from user-space
get a lock,
check for min/max acceptable values
save the value
release the lock.and a read function that:
write the config value to the "read" buffer.And so, I tried to come up with a way to avoid code duplication.
Quoted 7 lines
Quoted 4 lines
question: are only the names that are bad? (I agree that they are bad) or do you think that the overall idea is bad? :-)
Suggestions?
I don't think the overall idea is bad, if it is what I think you are doing. I just don't believe you articulated what you are doing.
I see!
Quoted 3 lines
It has nothing to do with 64 bit reads and writes, but instead has to do with reading and writing values that depend on each other for what is acceptable.
yeah, that is a better (starting point for an) explanation.
Quoted 2 lines
Perhaps have it called
trace_min_max_write()andtrace_min_max_read(), and document what it is used for.
I will do that!
-- Daniel
Quoted 2 lines
-- Steve
PATCH v3 6/9 trace/hwlat: Use the generic function to read/write width and window
In reply to Daniel Bristot de OliveiraUse the trace_ull_config generic implementation to reducing the code of hwlat detector.
--- kernel/trace/trace_hwlat.c | 135 ++++--------------------------------- 1 file changed, 14 insertions(+), 121 deletions(-)
kernel/trace/trace_hwlat.c +14 -121
@@ -504,115 +504,6 @@ static int start_per_cpu_kthreads(struct trace_array *tr)return 0 ; } -/* -* hwlat_read - Wrapper read function for reading both window and width -* @filp: The active open file structure -* @ubuf: The userspace provided buffer to read value into -* @cnt: The maximum number of bytes to read -* @ppos: The current "file" position -* -* This function provides a generic read implementation for the global state -* "hwlat_data" structure filesystem entries. -*/ -static ssize_t hwlat_read (struct file *filp,char __user *ubuf, -size_t cnt,loff_t *ppos) -{ -char buf[U64STR_SIZE ]; -u64 *entry = filp->private_data; -u64 val; -int len; - -if (!entry) -return -EFAULT ; - -if (cnt >sizeof (buf)) - cnt =sizeof (buf); - - val = *entry; - - len =snprintf (buf,sizeof (buf),"%llu\n" , val); - -return simple_read_from_buffer (ubuf, cnt, ppos, buf, len); -} - -/** -* hwlat_width_write - Write function for "width" entry -* @filp: The active open file structure -* @ubuf: The user buffer that contains the value to write -* @cnt: The maximum number of bytes to write to "file" -* @ppos: The current position in @file -* -* This function provides a write implementation for the "width" interface -* to the hardware latency detector. It can be used to configure -* for how many us of the total window us we will actively sample for any -* hardware-induced latency periods. Obviously, it is not possible to -* sample constantly and have the system respond to a sample reader, or, -* worse, without having the system appear to have gone out to lunch. It -* is enforced that width is less that the total window size. -*/ -static ssize_t -hwlat_width_write (struct file *filp,const char __user *ubuf, -size_t cnt,loff_t *ppos) -{ -u64 val; -int err; - - err =kstrtoull_from_user (ubuf, cnt,10 , &val); -if (err) -return err; - -mutex_lock (&hwlat_data.lock); -if (val < hwlat_data.sample_window) - hwlat_data.sample_width = val; -else - err = -EINVAL ; -mutex_unlock (&hwlat_data.lock); - -if (err) -return err; - -return cnt; -} - -/** -* hwlat_window_write - Write function for "window" entry -* @filp: The active open file structure -* @ubuf: The user buffer that contains the value to write -* @cnt: The maximum number of bytes to write to "file" -* @ppos: The current position in @file -* -* This function provides a write implementation for the "window" interface -* to the hardware latency detector. The window is the total time -* in us that will be considered one sample period. Conceptually, windows -* occur back-to-back and contain a sample width period during which -* actual sampling occurs. Can be used to write a new total window size. It -* is enforced that any value written must be greater than the sample width -* size, or an error results. -*/ -static ssize_t -hwlat_window_write (struct file *filp,const char __user *ubuf, -size_t cnt,loff_t *ppos) -{ -u64 val; -int err; - - err =kstrtoull_from_user (ubuf, cnt,10 , &val); -if (err) -return err; - -mutex_lock (&hwlat_data.lock); -if (hwlat_data.sample_width < val) - hwlat_data.sample_window = val; -else - err = -EINVAL ; -mutex_unlock (&hwlat_data.lock); - -if (err) -return err; - -return cnt; -} -static void *s_mode_start (struct seq_file *s,loff_t *pos) {int mode = *pos;
@@ -733,16 +624,18 @@ static ssize_t hwlat_mode_write(struct file *filp, const char __user *ubuf,return ret; } -static const struct file_operations width_fops = { - .open = tracing_open_generic, - .read = hwlat_read, - .write = hwlat_width_write, +static struct trace_ull_config hwlat_width = { + .lock = &hwlat_data.lock, + .val = &hwlat_data.sample_width, + .max = &hwlat_data.sample_window, + .min =NULL , }; -static const struct file_operations window_fops = { - .open = tracing_open_generic, - .read = hwlat_read, - .write = hwlat_window_write, +static struct trace_ull_config hwlat_window = { + .lock = &hwlat_data.lock, + .val = &hwlat_data.sample_window, + .max =NULL , + .min = &hwlat_data.sample_width, };static const struct file_operations thread_mode_fops = {
@@ -775,15 +668,15 @@ static int init_tracefs(void) hwlat_sample_window =tracefs_create_file ("window" ,0640 , top_dir, - &hwlat_data.sample_window, - &window_fops); + &hwlat_window, + &trace_ull_config_fops);if (!hwlat_sample_window) goto err; hwlat_sample_width =tracefs_create_file ("width" ,0644 , top_dir, - &hwlat_data.sample_width, - &width_fops); + &hwlat_width, + &trace_ull_config_fops);if (!hwlat_sample_width) goto err;
Signature · 1 line
2.26.3
Steven Rostedt
maintainerRe: [PATCH V3 6/9] trace/hwlat: Use the generic function to read/write width and window
Quoted 10 lines · On Fri, 14 May 2021 22:51:15 +0200 Daniel Bristot de Oliveira…
kernel/trace/trace_hwlat.c +2
-4@@ -733,16 +624,18 @@ static ssize_t hwlat_mode_write(struct file *filp, const char __user *ubuf,return ret; } -static const struct file_operations width_fops = { - .open = tracing_open_generic, - .read = hwlat_read, - .write = hwlat_width_write, +static struct trace_ull_config hwlat_width = { + .lock = &hwlat_data.lock,
kernel/trace/trace_hwlat.c static ssize_t hwlat_mode_write(struct file *filp, const char __user *ubuf, · line 634
Quoted 10 lines
kernel/trace/trace_hwlat.c +4
-4+ .val = &hwlat_data.sample_width, + .max = &hwlat_data.sample_window, + .min = NULL, }; -static const struct file_operations window_fops = { - .open = tracing_open_generic, - .read = hwlat_read, - .write = hwlat_window_write, +static struct trace_ull_config hwlat_window = {
Yeah, the naming convention needs to be changed, because ull_config is meaningless, and this code makes no sense. I know what it is doing, but if I didn't, I'd have no clue what it was doing by reading it. :-p
-- Steve
Quoted 27 lines
kernel/trace/trace_hwlat.c +8
-4+ .lock = &hwlat_data.lock, + .val = &hwlat_data.sample_window, + .max = NULL, + .min = &hwlat_data.sample_width, };static const struct file_operations thread_mode_fops = {@@ -775,15 +668,15 @@ static int init_tracefs(void) hwlat_sample_window =tracefs_create_file ("window" ,0640 , top_dir, - &hwlat_data.sample_window, - &window_fops); + &hwlat_window, + &trace_ull_config_fops);if (!hwlat_sample_window) goto err; hwlat_sample_width =tracefs_create_file ("width" ,0644 , top_dir, - &hwlat_data.sample_width, - &width_fops); + &hwlat_width, + &trace_ull_config_fops);if (!hwlat_sample_width) goto err;
Re: [PATCH V3 6/9] trace/hwlat: Use the generic function to read/write width and window
Quoted 18 lines · Steven Rostedt
Quoted 15 lines · On Fri, 14 May 2021 22:51:15 +0200 Daniel Bristot de Oliveira…
kernel/trace/trace_hwlat.c +5
-4@@ -733,16 +624,18 @@ static ssize_t hwlat_mode_write(struct file *filp, const char __user *ubuf,return ret; } -static const struct file_operations width_fops = { - .open = tracing_open_generic, - .read = hwlat_read, - .write = hwlat_width_write, +static struct trace_ull_config hwlat_width = { + .lock = &hwlat_data.lock, + .val = &hwlat_data.sample_width, + .max = &hwlat_data.sample_window, + .min =NULL , };
Quoted 8 lines
kernel/trace/trace_hwlat.c static ssize_t hwlat_mode_write(struct file *filp, const char __user *ubuf, · line 634
Quoted 5 lines
kernel/trace/trace_hwlat.c +1
-4-static const struct file_operations window_fops = { - .open = tracing_open_generic, - .read = hwlat_read, - .write = hwlat_window_write, +static struct trace_ull_config hwlat_window = {Yeah, the naming convention needs to be changed, because
ull_configis meaningless, and this code makes no sense. I know what it is doing, but if I didn't, I'd have no clue what it was doing by reading it. :-p
I will rework the patch 5/9 to add a better explanation for the read/write functions, and I will add comments to this patch, explaining the reason for the min/max values.
Sound good?
-- Daniel
Quoted 3 lines
-- Steve
Steven Rostedt
maintainerRe: [PATCH V3 6/9] trace/hwlat: Use the generic function to read/write width and window
Quoted 5 lines · On Fri, 4 Jun 2021 18:36:58 +0200 Daniel Bristot de Oliveira…
I will rework the patch 5/9 to add a better explanation for the read/write functions, and I will add comments to this patch, explaining the reason for the min/max values.
Sound good?
We'll see in v4 ;-)
-- Steve
PATCH v3 7/9 tracing: Add __print_ns_to_secs() and __print_ns_without_secs() helpers
In reply to Daniel Bristot de OliveiraFrom: Steven Rostedt <[email protected]>
To have nanosecond output displayed in a more human readable format, its nicer to convert it to a seconds format (XXX.YYYYYYYYY). The problem is that to do so, the numbers must be divided by NSEC_PER_SEC, and moded too. But as these numbers are 64 bit, this can not be done simply with '/' and '%' operators, but must use do_div() instead.
Instead of performing the expensive do_div() in the hot path of the tracepoint, it is more efficient to perform it during the output phase. But passing in do_div() can confuse the parser, and do_div() doesn't work exactly like a normal C function. It modifies the number in place, and we don't want to modify the actual values in the ring buffer.
Two helper functions are now created:
__print_ns_to_secs() and __print_ns_without_secs()
They both take a value of nanoseconds, and the former will return that number divided by NSEC_PER_SEC, and the latter will mod it with NSEC_PER_SEC giving a way to print a nice human readable format:
__print_fmt("time=%llu.%09u",
__print_ns_to_secs(REC->nsec_val), __print_ns_without_secs(REC->nsec_val))
--- include/trace/trace_events.h | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+)
include/trace/trace_events.h +25 -0
@@ -358,6 +358,21 @@ TRACE_MAKE_SYSTEM_STR();trace_print_hex_dump_seq (p, prefix_str, prefix_type, \ rowsize, groupsize, buf, len, ascii) +#undef __print_ns_to_secs +#define __print_ns_to_secs (value) \ + ({ \ + u64 ____val = (u64)value; \ + do_div(____val, NSEC_PER_SEC); \ + ____val; \ + }) + +#undef __print_ns_without_secs +#define __print_ns_without_secs (value) \ + ({ \ + u64 ____val = (u64)value; \ + (u32) do_div(____val, NSEC_PER_SEC); \ + }) +#undef DECLARE_EVENT_CLASS#define DECLARE_EVENT_CLASS (call, proto, args, tstruct, assign, print) \ static notrace enum print_line_t \
@@ -736,6 +751,16 @@ static inline void ftrace_test_probe_##call(void) \#undef __print_array#undef __print_hex_dump +/* +* The below is not executed in the kernel. It is only what is +* displayed in the print format for userspace to parse. +*/ +#undef __print_ns_to_secs +#define __print_ns_to_secs (val) val / 1000000000UL + +#undef __print_ns_without_secs +#define __print_ns_without_secs (val) val % 1000000000UL +#undef TP_printk #define TP_printk(fmt, args...) "\"" fmt "\", " __stringify(args)
Signature · 1 line
2.26.3
Steven Rostedt
maintainerRe: [PATCH V3 7/9] tracing: Add __print_ns_to_secs() and __print_ns_without_secs() helpers
include/trace/trace_events.h TRACE_MAKE_SYSTEM_STR(); · line 367
Quoted 12 lines · On Fri, 14 May 2021 22:51:16 +0200 Daniel Bristot de Oliveira…
+++
b/include/trace/trace_events.hinclude/trace/trace_events.h +7
-0@@ -358,6 +358,21 @@ TRACE_MAKE_SYSTEM_STR();trace_print_hex_dump_seq (p, prefix_str, prefix_type, \ rowsize, groupsize, buf, len, ascii) +#undef __print_ns_to_secs +#define __print_ns_to_secs (value) \ + ({ \ + u64 ____val = (u64)value; \ + do_div(____val, NSEC_PER_SEC); \ + ____val; \ + })
I know my name is on this, but we need parenthesis around "value".
include/trace/trace_events.h TRACE_MAKE_SYSTEM_STR(); · line 372
Quoted 5 lines
include/trace/trace_events.h +5
-0+ +#undef __print_ns_without_secs +#define __print_ns_without_secs (value) \ + ({ \ + u64 ____val = (u64)value; \
Here too.
Quoted 9 lines
include/trace/trace_events.h +3
-0+ (u32 )do_div (____val,NSEC_PER_SEC ); \ + }) +#undef DECLARE_EVENT_CLASS#define DECLARE_EVENT_CLASS (call, proto, args, tstruct, assign, print) \ static notrace enum print_line_t \@@ -736,6 +751,16 @@ static inline void ftrace_test_probe_##call(void) \#undef __print_array#undef __print_hex_dump
include/trace/trace_events.h static inline void ftrace_test_probe_##call(void) \ · line 762
Quoted 10 lines
include/trace/trace_events.h +9
-0+/* +* The below is not executed in the kernel. It is only what is +* displayed in the print format for userspace to parse. +*/ +#undef __print_ns_to_secs +#define __print_ns_to_secs (val) val / 1000000000UL + +#undef __print_ns_without_secs +#define __print_ns_without_secs (val) val % 1000000000UL
And around "val" in the above two macros.
-- Steve
Quoted 4 lines
include/trace/trace_events.h +1
-0+#undef TP_printk #define TP_printk(fmt, args...) "\"" fmt "\", " __stringify(args)
Re: [PATCH V3 7/9] tracing: Add __print_ns_to_secs() and __print_ns_without_secs() helpers
Quoted 6 lines · Steven Rostedt
Quoted 6 lines
+++
b/include/trace/trace_events.h(quoted diff) +0
-0@@ -358,6 +358,21 @@ TRACE_MAKE_SYSTEM_STR(); trace_print_hex_dump_seq(p, prefix_str, prefix_type, \ rowsize, groupsize, buf, len, ascii)
Quoted 9 lines
Review
Quoted 7 lines
(quoted diff) +7
-0+#undef __print_ns_to_secs +#define __print_ns_to_secs(value) \ + ({ \ + u64 ____val = (u64)value; \ + do_div(____val, NSEC_PER_SEC); \ + ____val; \ + })I know my name is on this, but we need parenthesis around "value".
If tracing cleanups for trace_events.h are being done, perhaps another bit of untidiness is the macro definition and uses of __assign_str.
$ git grep -w -1 __assign_str include/trace/trace_events.h include/trace/trace_events.h- include/trace/trace_events.h:#undef __assign_str include/trace/trace_events.h:#define __assign_str(dst, src) \ include/trace/trace_events.h- strcpy(__get_str(dst), (src) ? (const char *)(src) : "(null)");
Its definition has a semicolon as do most uses but a dozen handfuls of other uses do not have a semicolon. It'd be more consistent to add a semicolon to the uses without them and when done treewide, then remove the semicolon from the macro declaration.
$ git grep -P '\b__assign_str\b' | wc -l 551 $ git grep -P '\b__assign_str\b.*;' | wc -l 480
For instance: sunrpc.h has a mixture of uses with and without semicolons.
$ git grep -P '\b__assign_str\b' include/trace/events/sunrpc.h | wc -l 65 $ git grep -P '\b__assign_str\b.*;' include/trace/events/sunrpc.h | wc -l 38
It's especially odd in the last block below to have 3 successive uses where the first and last has a semicolon, but the middle one does not.
So perhaps as a start:
--- include/trace/events/sunrpc.h | 40 ++++++++++++++++++++-------------------- 1 file changed, 20 insertions(+), 20 deletions(-)
include/trace/events/sunrpc.h +20 -20
@@ -154,8 +154,8 @@ TRACE_EVENT(rpc_clnt_new, __entry->client_id = clnt->cl_clid;__assign_str (addr, xprt->address_strings[RPC_DISPLAY_ADDR ]);__assign_str (port, xprt->address_strings[RPC_DISPLAY_PORT ]); - __assign_str(program, program) -__assign_str (server, server) +__assign_str (program, program); +__assign_str (server, server); ), TP_printk("client=%u peer=[%s]:%s program=%s server=%s",
@@ -180,8 +180,8 @@ TRACE_EVENT(rpc_clnt_new_err,TP_fast_assign ( __entry->error = error; - __assign_str(program, program) -__assign_str (server, server) +__assign_str (program, program); +__assign_str (server, server); ), TP_printk("program=%s server=%s error=%d",
@@ -284,8 +284,8 @@ TRACE_EVENT(rpc_request, __entry->client_id = task->tk_client->cl_clid; __entry->version = task->tk_client->cl_vers; __entry->async =RPC_IS_ASYNC (task); - __assign_str(progname, task->tk_client->cl_program->name) -__assign_str (procname,rpc_proc_name (task)) +__assign_str (progname, task->tk_client->cl_program->name); +__assign_str (procname,rpc_proc_name (task)); ), TP_printk("task:%u@%u %sv%d %s (%ssync)",
@@ -494,10 +494,10 @@ DECLARE_EVENT_CLASS(rpc_reply_event, __entry->task_id = task->tk_pid; __entry->client_id = task->tk_client->cl_clid; __entry->xid =be32_to_cpu (task->tk_rqstp->rq_xid); -__assign_str (progname, task->tk_client->cl_program->name) +__assign_str (progname, task->tk_client->cl_program->name); __entry->version = task->tk_client->cl_vers; - __assign_str(procname, rpc_proc_name(task)) -__assign_str (servername, task->tk_xprt->servername) +__assign_str (procname,rpc_proc_name (task)); +__assign_str (servername, task->tk_xprt->servername); ), TP_printk("task:%u@%d server=%s xid=0x%08x %sv%d %s",
@@ -622,8 +622,8 @@ TRACE_EVENT(rpc_stats_latency, __entry->task_id = task->tk_pid; __entry->xid =be32_to_cpu (task->tk_rqstp->rq_xid); __entry->version = task->tk_client->cl_vers; - __assign_str(progname, task->tk_client->cl_program->name) -__assign_str (procname,rpc_proc_name (task)) +__assign_str (progname, task->tk_client->cl_program->name); +__assign_str (procname,rpc_proc_name (task)); __entry->backlog =ktime_to_us (backlog); __entry->rtt =ktime_to_us (rtt); __entry->execute =ktime_to_us (execute);
@@ -669,15 +669,15 @@ TRACE_EVENT(rpc_xdr_overflow, __entry->task_id = task->tk_pid; __entry->client_id = task->tk_client->cl_clid;__assign_str (progname, - task->tk_client->cl_program->name) + task->tk_client->cl_program->name); __entry->version = task->tk_client->cl_vers; - __assign_str(procedure, task->tk_msg.rpc_proc->p_name) +__assign_str (procedure, task->tk_msg.rpc_proc->p_name); }else { __entry->task_id =0 ; __entry->client_id =0 ; -__assign_str (progname,"unknown" ) +__assign_str (progname,"unknown" ); __entry->version =0 ; - __assign_str(procedure, "unknown") +__assign_str (procedure,"unknown" ); } __entry->requested = requested; __entry->end = xdr->end;
@@ -735,9 +735,9 @@ TRACE_EVENT(rpc_xdr_alignment, __entry->task_id = task->tk_pid; __entry->client_id = task->tk_client->cl_clid;__assign_str (progname, - task->tk_client->cl_program->name) + task->tk_client->cl_program->name); __entry->version = task->tk_client->cl_vers; -__assign_str (procedure, task->tk_msg.rpc_proc->p_name) +__assign_str (procedure, task->tk_msg.rpc_proc->p_name); __entry->offset = offset; __entry->copied = copied;
@@ -1107,9 +1107,9 @@ TRACE_EVENT(xprt_retransmit, __entry->xid =be32_to_cpu (rqst->rq_xid); __entry->ntrans = rqst->rq_ntrans;__assign_str (progname, - task->tk_client->cl_program->name) + task->tk_client->cl_program->name); __entry->version = task->tk_client->cl_vers; -__assign_str (procedure, task->tk_msg.rpc_proc->p_name) +__assign_str (procedure, task->tk_msg.rpc_proc->p_name); ), TP_printk(
@@ -1842,7 +1842,7 @@ TRACE_EVENT(svc_xprt_accept,TP_fast_assign ( __assign_str(addr, xprt->xpt_remotebuf); - __assign_str(protocol, xprt->xpt_class->xcl_name) +__assign_str (protocol, xprt->xpt_class->xcl_name);__assign_str (service, service); ),
Steven Rostedt
maintainerRe: [PATCH V3 7/9] tracing: Add __print_ns_to_secs() and __print_ns_without_secs() helpers
Quoted 3 lines · On Thu, 03 Jun 2021 21:19:50 -0700 Joe Perches <[email protected]> wrote:
If tracing cleanups for
trace_events.hare being done, perhaps another bit of untidiness is the macro definition and uses of__assign_str.
This isn't a tracing cleanup, but adding new functionality.
That said,
Quoted 11 lines
$ git grep -w -1 __assign_str include/trace/trace_events.h include/trace/trace_events.h- include/trace/trace_events.h:#undef __assign_str include/trace/trace_events.h:#define __assign_str(dst, src) \ include/trace/trace_events.h- strcpy(__get_str(dst), (src) ? (const char *)(src) : "(null)");Its definition has a semicolon as do most uses but a dozen handfuls of other uses do not have a semicolon. It'd be more consistent to add a semicolon to the uses without them and when done treewide, then remove the semicolon from the macro declaration.
I have no problem taking a clean up patch that adds semicolons to all use cases of "__assign_str()" and ever remove the one from where it is defined. As long as it doesn't break any builds, I'm fine with that.
-- Steve
PATCH 1/1 treewide: Add missing semicolons to __assign_str uses
The __assign_str macro has an unusual ending semicolon but the vast majority of uses of the macro already have semicolon termination.
$ git grep -P '\b__assign_str\b' | wc -l 551 $ git grep -P '\b__assign_str\b.*;' | wc -l 480
Add semicolons to the __assign_str() uses without semicolon termination and all the other uses without semicolon termination via additional defines that are equivalent to __assign_str() with the eventual goal of removing the semicolon from the __assign_str() macro definition.
---
Compiled x84-64 allyesconfig
Quoted 3 lines · Steven Rostedt
I have no problem taking a clean up patch that adds semicolons to all use cases of "
__assign_str()" and ever remove the one from where it is defined. As long as it doesn't break any builds, I'm fine with that.
Removing the semicolon from the macro definition is left for another patch.
drivers/gpu/drm/amd/amdgpu/amdgpu_trace.h | 14 ++++---- drivers/gpu/drm/lima/lima_trace.h | 2 +- drivers/infiniband/hw/hfi1/trace_misc.h | 4 +-- drivers/infiniband/hw/hfi1/trace_rc.h | 4 +-- drivers/infiniband/hw/hfi1/trace_tid.h | 6 ++-- drivers/infiniband/hw/hfi1/trace_tx.h | 8 ++--- drivers/infiniband/sw/rdmavt/trace_cq.h | 4 +-- drivers/infiniband/sw/rdmavt/trace_mr.h | 2 +- drivers/infiniband/sw/rdmavt/trace_qp.h | 4 +-- drivers/infiniband/sw/rdmavt/trace_rc.h | 2 +- drivers/infiniband/sw/rdmavt/trace_tx.h | 4 +-- drivers/misc/mei/mei-trace.h | 6 ++-- .../net/ethernet/marvell/octeontx2/af/rvu_trace.h | 12 +++---- drivers/net/fjes/fjes_trace.h | 4 +-- drivers/usb/cdns3/cdnsp-trace.h | 2 +- fs/nfs/nfs4trace.h | 6 ++-- fs/nfs/nfstrace.h | 4 +-- include/trace/events/btrfs.h | 2 +- include/trace/events/dma_fence.h | 4 +-- include/trace/events/rpcgss.h | 4 +-- include/trace/events/sunrpc.h | 40 +++++++++++----------- net/mac80211/trace.h | 2 +- 22 files changed, 70 insertions(+), 70 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_trace.h +7 -7
@@ -176,10 +176,10 @@ TRACE_EVENT(amdgpu_cs_ioctl,TP_fast_assign ( __entry->sched_job_id = job->base.id; -__assign_str (timeline,AMDGPU_JOB_GET_TIMELINE_NAME (job)) +__assign_str (timeline,AMDGPU_JOB_GET_TIMELINE_NAME (job)); __entry->context = job->base.s_fence->finished.context; __entry->seqno = job->base.s_fence->finished.seqno; -__assign_str (ring,to_amdgpu_ring (job->base.sched)->name) +__assign_str (ring,to_amdgpu_ring (job->base.sched)->name); __entry->num_ibs = job->num_ibs; ), TP_printk("sched_job=%llu, timeline=%s, context=%u, seqno=%u, ring_name=%s, num_ibs=%u",
@@ -201,10 +201,10 @@ TRACE_EVENT(amdgpu_sched_run_job,TP_fast_assign ( __entry->sched_job_id = job->base.id; -__assign_str (timeline,AMDGPU_JOB_GET_TIMELINE_NAME (job)) +__assign_str (timeline,AMDGPU_JOB_GET_TIMELINE_NAME (job)); __entry->context = job->base.s_fence->finished.context; __entry->seqno = job->base.s_fence->finished.seqno; -__assign_str (ring,to_amdgpu_ring (job->base.sched)->name) +__assign_str (ring,to_amdgpu_ring (job->base.sched)->name); __entry->num_ibs = job->num_ibs; ), TP_printk("sched_job=%llu, timeline=%s, context=%u, seqno=%u, ring_name=%s, num_ibs=%u",
@@ -229,7 +229,7 @@ TRACE_EVENT(amdgpu_vm_grab_id,TP_fast_assign ( __entry->pasid = vm->pasid; -__assign_str (ring, ring->name) +__assign_str (ring, ring->name); __entry->vmid = job->vmid; __entry->vm_hub = ring->funcs->vmhub, __entry->pd_addr = job->vm_pd_addr;
@@ -424,7 +424,7 @@ TRACE_EVENT(amdgpu_vm_flush, ), TP_fast_assign( -__assign_str (ring, ring->name) + __assign_str(ring, ring->name); __entry->vmid = vmid; __entry->vm_hub = ring->funcs->vmhub; __entry->pd_addr = pd_addr;
@@ -525,7 +525,7 @@ TRACE_EVENT(amdgpu_ib_pipe_sync, ),TP_fast_assign ( -__assign_str (ring, sched_job->base.sched->name) + __assign_str(ring, sched_job->base.sched->name); __entry->id = sched_job->base.id; __entry->fence = fence; __entry->ctx = fence->context;
drivers/gpu/drm/lima/lima_trace.h +1 -1
@@ -24,7 +24,7 @@ DECLARE_EVENT_CLASS(lima_task, __entry->task_id = task->base.id; __entry->context = task->base.s_fence->finished.context; __entry->seqno = task->base.s_fence->finished.seqno; -__assign_str (pipe, task->base.sched->name) +__assign_str (pipe, task->base.sched->name); ), TP_printk("task=%llu, context=%u seqno=%u pipe=%s",
drivers/infiniband/hw/hfi1/trace_misc.h +2 -2
@@ -63,7 +63,7 @@ TRACE_EVENT(hfi1_interrupt, __array(char, buf, 64)__field (int, src) ), -TP_fast_assign (DD_DEV_ASSIGN (dd) + TP_fast_assign(DD_DEV_ASSIGN(dd); is_entry->is_name (__entry->buf,64 , src - is_entry->start); __entry->src = src;
@@ -100,7 +100,7 @@ TRACE_EVENT(hfi1_fault_opcode, __field(u32, qpn)__field (u8, opcode) ), -TP_fast_assign (DD_DEV_ASSIGN (dd_from_ibdev (qp->ibqp.device)) + TP_fast_assign(DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device)); __entry->qpn = qp->ibqp.qp_num; __entry->opcode = opcode; ),
drivers/infiniband/hw/hfi1/trace_rc.h +2 -2
@@ -70,7 +70,7 @@ DECLARE_EVENT_CLASS(hfi1_rc_template,__field (u32, r_psn) ),TP_fast_assign ( -DD_DEV_ASSIGN (dd_from_ibdev (qp->ibqp.device)) + DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device)); __entry->qpn = qp->ibqp.qp_num; __entry->s_flags = qp->s_flags; __entry->psn = psn;
@@ -130,7 +130,7 @@ DECLARE_EVENT_CLASS(/* rc_ack */__field (u32, lpsn) ),TP_fast_assign (/* assign */ -DD_DEV_ASSIGN (dd_from_ibdev (qp->ibqp.device)) + DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device)); __entry->qpn = qp->ibqp.qp_num; __entry->aeth = aeth; __entry->psn = psn;
drivers/infiniband/hw/hfi1/trace_tid.h +3 -3
@@ -886,7 +886,7 @@ DECLARE_EVENT_CLASS(/* sender_info */__field (u8, s_retry) ),TP_fast_assign (/* assign */ -DD_DEV_ASSIGN (dd_from_ibdev (qp->ibqp.device)) + DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device)); __entry->qpn = qp->ibqp.qp_num; __entry->state = qp->state; __entry->s_cur = qp->s_cur;
@@ -1285,7 +1285,7 @@ DECLARE_EVENT_CLASS(/* rc_rcv_err */__field (int, diff) ),TP_fast_assign (/* assign */ -DD_DEV_ASSIGN (dd_from_ibdev (qp->ibqp.device)) + DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device)); __entry->qpn = qp->ibqp.qp_num; __entry->s_flags = qp->s_flags; __entry->state = qp->state;
@@ -1574,7 +1574,7 @@ DECLARE_EVENT_CLASS(/* tid_ack */__field (u32, resync_psn) ),TP_fast_assign (/* assign */ -DD_DEV_ASSIGN (dd_from_ibdev (qp->ibqp.device)) + DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device)); __entry->qpn = qp->ibqp.qp_num; __entry->aeth = aeth; __entry->psn = psn;
drivers/infiniband/hw/hfi1/trace_tx.h +4 -4
@@ -120,7 +120,7 @@ DECLARE_EVENT_CLASS(hfi1_qpsleepwakeup_template, __field(unsigned long, iow_flags) ),TP_fast_assign ( - DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device)) + DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device)); __entry->flags = flags; __entry->qpn = qp->ibqp.qp_num; __entry->s_flags = qp->s_flags;
@@ -868,7 +868,7 @@ TRACE_EVENT(__field (int, send_flags) ),TP_fast_assign ( -DD_DEV_ASSIGN (dd_from_ibdev (qp->ibqp.device)) + DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device)); __entry->wqe = wqe; __entry->wr_id = wqe->wr.wr_id; __entry->qpn = qp->ibqp.qp_num;
@@ -904,7 +904,7 @@ DECLARE_EVENT_CLASS(__field (bool, flag) ),TP_fast_assign ( -DD_DEV_ASSIGN (dd_from_ibdev (qp->ibqp.device)) + DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device)); __entry->qpn = qp->ibqp.qp_num; __entry->flag = flag; ),
@@ -952,7 +952,7 @@ DECLARE_EVENT_CLASS(/* AIP */__field (u8, stopped) ),TP_fast_assign (/* assign */ -DD_DEV_ASSIGN (txq->priv->dd) + DD_DEV_ASSIGN(txq->priv->dd); __entry->txq = txq; __entry->sde = txq->sde; __entry->head = txq->tx_ring.head;
drivers/infiniband/sw/rdmavt/trace_cq.h +2 -2
@@ -85,7 +85,7 @@ DECLARE_EVENT_CLASS(rvt_cq_template, __field(int, comp_vector_cpu)__field (u32, flags) ), -TP_fast_assign (RDI_DEV_ASSIGN (cq->rdi) + TP_fast_assign(RDI_DEV_ASSIGN(cq->rdi); __entry->ip = cq->ip; __entry->cqe = attr->cqe; __entry->comp_vector = attr->comp_vector;
@@ -123,7 +123,7 @@ DECLARE_EVENT_CLASS(__field (u32, imm) ),TP_fast_assign ( -RDI_DEV_ASSIGN (cq->rdi) + RDI_DEV_ASSIGN(cq->rdi); __entry->wr_id = wc->wr_id; __entry->status = wc->status; __entry->opcode = wc->opcode;
drivers/infiniband/sw/rdmavt/trace_mr.h +1 -1
@@ -195,7 +195,7 @@ TRACE_EVENT(__field (uint, sg_offset) ),TP_fast_assign ( -RDI_DEV_ASSIGN (ib_to_rvt (to_imr (ibmr)->mr.pd->device)) + RDI_DEV_ASSIGN(ib_to_rvt(to_imr(ibmr)->mr.pd->device)); __entry->ibmr_iova = ibmr->iova; __entry->iova =to_imr (ibmr)->mr.iova; __entry->user_base =to_imr (ibmr)->mr.user_base;
drivers/infiniband/sw/rdmavt/trace_qp.h +2 -2
@@ -65,7 +65,7 @@ DECLARE_EVENT_CLASS(rvt_qphash_template,__field (u32, bucket) ),TP_fast_assign ( -RDI_DEV_ASSIGN (ib_to_rvt (qp->ibqp.device)) + RDI_DEV_ASSIGN(ib_to_rvt(qp->ibqp.device)); __entry->qpn = qp->ibqp.qp_num; __entry->bucket = bucket; ),
@@ -97,7 +97,7 @@ DECLARE_EVENT_CLASS(__field (u32, to) ),TP_fast_assign ( -RDI_DEV_ASSIGN (ib_to_rvt (qp->ibqp.device)) + RDI_DEV_ASSIGN(ib_to_rvt(qp->ibqp.device)); __entry->qpn = qp->ibqp.qp_num; __entry->hrtimer = &qp->s_rnr_timer; __entry->s_flags = qp->s_flags;
drivers/infiniband/sw/rdmavt/trace_rc.h +1 -1
@@ -71,7 +71,7 @@ DECLARE_EVENT_CLASS(rvt_rc_template,__field (u32, r_psn) ),TP_fast_assign ( -RDI_DEV_ASSIGN (ib_to_rvt (qp->ibqp.device)) + RDI_DEV_ASSIGN(ib_to_rvt(qp->ibqp.device)); __entry->qpn = qp->ibqp.qp_num; __entry->s_flags = qp->s_flags; __entry->psn = psn;
drivers/infiniband/sw/rdmavt/trace_tx.h +2 -2
@@ -111,7 +111,7 @@ TRACE_EVENT(__field (int, wr_num_sge) ),TP_fast_assign ( -RDI_DEV_ASSIGN (ib_to_rvt (qp->ibqp.device)) + RDI_DEV_ASSIGN(ib_to_rvt(qp->ibqp.device)); __entry->wqe = wqe; __entry->wr_id = wqe->wr.wr_id; __entry->qpn = qp->ibqp.qp_num;
@@ -170,7 +170,7 @@ TRACE_EVENT(__field (int, send_flags) ),TP_fast_assign ( -RDI_DEV_ASSIGN (ib_to_rvt (qp->ibqp.device)) + RDI_DEV_ASSIGN(ib_to_rvt(qp->ibqp.device)); __entry->wqe = wqe; __entry->wr_id = wqe->wr.wr_id; __entry->qpn = qp->ibqp.qp_num;
drivers/misc/mei/mei-trace.h +3 -3
@@ -26,7 +26,7 @@ TRACE_EVENT(mei_reg_read,__field (u32, val) ),TP_fast_assign ( -__assign_str (dev,dev_name (dev)) + __assign_str(dev, dev_name(dev)); __entry->reg = reg; __entry->offs = offs; __entry->val = val;
@@ -45,7 +45,7 @@ TRACE_EVENT(mei_reg_write,__field (u32, val) ),TP_fast_assign ( -__assign_str (dev,dev_name (dev)) + __assign_str(dev, dev_name(dev)); __entry->reg = reg; __entry->offs = offs; __entry->val = val;
@@ -64,7 +64,7 @@ TRACE_EVENT(mei_pci_cfg_read,__field (u32, val) ),TP_fast_assign ( -__assign_str (dev,dev_name (dev)) + __assign_str(dev, dev_name(dev)); __entry->reg = reg; __entry->offs = offs; __entry->val = val;
drivers/net/ethernet/marvell/octeontx2/af/rvu_trace.h +6 -6
@@ -21,7 +21,7 @@ TRACE_EVENT(otx2_msg_alloc, __field(u16, id)__field (u64, size) ), -TP_fast_assign (__assign_str (dev,pci_name (pdev)) + TP_fast_assign(__assign_str(dev, pci_name(pdev)); __entry->id = id; __entry->size = size; ),
@@ -36,7 +36,7 @@ TRACE_EVENT(otx2_msg_send, __field(u16, num_msgs)__field (u64, msg_size) ), -TP_fast_assign (__assign_str (dev,pci_name (pdev)) + TP_fast_assign(__assign_str(dev, pci_name(pdev)); __entry->num_msgs = num_msgs; __entry->msg_size = msg_size; ),
@@ -52,7 +52,7 @@ TRACE_EVENT(otx2_msg_check, __field(u16, rspid)__field (int, rc) ), -TP_fast_assign (__assign_str (dev,pci_name (pdev)) + TP_fast_assign(__assign_str(dev, pci_name(pdev)); __entry->reqid = reqid; __entry->rspid = rspid; __entry->rc = rc;
@@ -69,8 +69,8 @@ TRACE_EVENT(otx2_msg_interrupt, __string(str, msg)__field (u64, intr) ), - TP_fast_assign(__assign_str(dev, pci_name(pdev)) - __assign_str(str, msg) + TP_fast_assign(__assign_str(dev, pci_name(pdev)); +__assign_str (str, msg); __entry->intr = intr; ), TP_printk("[%s] mbox interrupt %s (0x%llx)\n", __get_str(dev),
@@ -84,7 +84,7 @@ TRACE_EVENT(otx2_msg_process, __field(u16, id)__field (int, err) ), -TP_fast_assign (__assign_str (dev,pci_name (pdev)) + TP_fast_assign(__assign_str(dev, pci_name(pdev)); __entry->id = id; __entry->err = err; ),
drivers/net/fjes/fjes_trace.h +2 -2
@@ -232,7 +232,7 @@ TRACE_EVENT(fjes_hw_start_debug_err,__string (err, err) ),TP_fast_assign ( -__assign_str (err, err) + __assign_str(err, err); ),TP_printk ("%s" ,__get_str (err)) );
@@ -258,7 +258,7 @@ TRACE_EVENT(fjes_hw_stop_debug_err,__string (err, err) ),TP_fast_assign ( -__assign_str (err, err) + __assign_str(err, err); ),TP_printk ("%s" ,__get_str (err)) );
drivers/usb/cdns3/cdnsp-trace.h +1 -1
@@ -138,7 +138,7 @@ DECLARE_EVENT_CLASS(cdnsp_log_simple,__string (text, msg) ),TP_fast_assign ( -__assign_str (text, msg) + __assign_str(text, msg); ),TP_printk ("%s" ,__get_str (text)) );
fs/nfs/nfs4trace.h +3 -3
@@ -625,7 +625,7 @@ TRACE_EVENT(nfs4_state_mgr,TP_fast_assign ( __entry->state = clp->cl_state; -__assign_str (hostname, clp->cl_hostname) +__assign_str (hostname, clp->cl_hostname); ), TP_printk(
@@ -1637,7 +1637,7 @@ DECLARE_EVENT_CLASS(nfs4_inode_callback_event, __entry->fileid =0 ; __entry->dev =0 ; } -__assign_str (dstaddr, clp ? clp->cl_hostname :"unknown" ) +__assign_str (dstaddr, clp ? clp->cl_hostname :"unknown" ); ), TP_printk(
@@ -1694,7 +1694,7 @@ DECLARE_EVENT_CLASS(nfs4_inode_stateid_callback_event, __entry->fileid =0 ; __entry->dev =0 ; } -__assign_str (dstaddr, clp ? clp->cl_hostname :"unknown" ) +__assign_str (dstaddr, clp ? clp->cl_hostname :"unknown" ); __entry->stateid_seq =be32_to_cpu (stateid->seqid); __entry->stateid_hash =
fs/nfs/nfstrace.h +2 -2
@@ -1431,8 +1431,8 @@ DECLARE_EVENT_CLASS(nfs_xdr_event, __entry->version = task->tk_client->cl_vers; __entry->error = error;__assign_str (program, - task->tk_client->cl_program->name) -__assign_str (procedure, task->tk_msg.rpc_proc->p_name) + task->tk_client->cl_program->name); +__assign_str (procedure, task->tk_msg.rpc_proc->p_name); ), TP_printk(
include/trace/events/btrfs.h +1 -1
@@ -1093,7 +1093,7 @@ TRACE_EVENT(btrfs_trigger_flush, __entry->flags = flags; __entry->bytes = bytes; __entry->flush = flush; -__assign_str (reason, reason) +__assign_str (reason, reason); ), TP_printk_btrfs("%s: flush=%d(%s) flags=%llu(%s) bytes=%llu",
include/trace/events/dma_fence.h +2 -2
@@ -23,8 +23,8 @@ DECLARE_EVENT_CLASS(dma_fence, ),TP_fast_assign ( - __assign_str(driver, fence->ops->get_driver_name(fence)) - __assign_str(timeline, fence->ops->get_timeline_name(fence)) + __assign_str(driver, fence->ops->get_driver_name(fence)); +__assign_str (timeline, fence->ops->get_timeline_name (fence)); __entry->context = fence->context; __entry->seqno = fence->seqno; ),
include/trace/events/rpcgss.h +2 -2
@@ -152,7 +152,7 @@ DECLARE_EVENT_CLASS(rpcgss_ctx_class,TP_fast_assign ( __entry->cred = gc; __entry->service = gc->gc_service; -__assign_str (principal, gc->gc_principal) +__assign_str (principal, gc->gc_principal); ), TP_printk("cred=%p service=%s principal='%s'",
@@ -535,7 +535,7 @@ TRACE_EVENT(rpcgss_upcall_msg, ),TP_fast_assign ( -__assign_str (msg, buf) + __assign_str(msg, buf); ),TP_printk ("msg='%s'" ,__get_str (msg))
include/trace/events/sunrpc.h +20 -20
@@ -154,8 +154,8 @@ TRACE_EVENT(rpc_clnt_new, __entry->client_id = clnt->cl_clid;__assign_str (addr, xprt->address_strings[RPC_DISPLAY_ADDR ]);__assign_str (port, xprt->address_strings[RPC_DISPLAY_PORT ]); - __assign_str(program, program) -__assign_str (server, server) +__assign_str (program, program); +__assign_str (server, server); ), TP_printk("client=%u peer=[%s]:%s program=%s server=%s",
@@ -180,8 +180,8 @@ TRACE_EVENT(rpc_clnt_new_err,TP_fast_assign ( __entry->error = error; - __assign_str(program, program) -__assign_str (server, server) +__assign_str (program, program); +__assign_str (server, server); ), TP_printk("program=%s server=%s error=%d",
@@ -284,8 +284,8 @@ TRACE_EVENT(rpc_request, __entry->client_id = task->tk_client->cl_clid; __entry->version = task->tk_client->cl_vers; __entry->async =RPC_IS_ASYNC (task); - __assign_str(progname, task->tk_client->cl_program->name) -__assign_str (procname,rpc_proc_name (task)) +__assign_str (progname, task->tk_client->cl_program->name); +__assign_str (procname,rpc_proc_name (task)); ), TP_printk("task:%u@%u %sv%d %s (%ssync)",
@@ -494,10 +494,10 @@ DECLARE_EVENT_CLASS(rpc_reply_event, __entry->task_id = task->tk_pid; __entry->client_id = task->tk_client->cl_clid; __entry->xid =be32_to_cpu (task->tk_rqstp->rq_xid); -__assign_str (progname, task->tk_client->cl_program->name) +__assign_str (progname, task->tk_client->cl_program->name); __entry->version = task->tk_client->cl_vers; - __assign_str(procname, rpc_proc_name(task)) -__assign_str (servername, task->tk_xprt->servername) +__assign_str (procname,rpc_proc_name (task)); +__assign_str (servername, task->tk_xprt->servername); ), TP_printk("task:%u@%d server=%s xid=0x%08x %sv%d %s",
@@ -622,8 +622,8 @@ TRACE_EVENT(rpc_stats_latency, __entry->task_id = task->tk_pid; __entry->xid =be32_to_cpu (task->tk_rqstp->rq_xid); __entry->version = task->tk_client->cl_vers; - __assign_str(progname, task->tk_client->cl_program->name) -__assign_str (procname,rpc_proc_name (task)) +__assign_str (progname, task->tk_client->cl_program->name); +__assign_str (procname,rpc_proc_name (task)); __entry->backlog =ktime_to_us (backlog); __entry->rtt =ktime_to_us (rtt); __entry->execute =ktime_to_us (execute);
@@ -669,15 +669,15 @@ TRACE_EVENT(rpc_xdr_overflow, __entry->task_id = task->tk_pid; __entry->client_id = task->tk_client->cl_clid;__assign_str (progname, - task->tk_client->cl_program->name) + task->tk_client->cl_program->name); __entry->version = task->tk_client->cl_vers; - __assign_str(procedure, task->tk_msg.rpc_proc->p_name) +__assign_str (procedure, task->tk_msg.rpc_proc->p_name); }else { __entry->task_id =0 ; __entry->client_id =0 ; -__assign_str (progname,"unknown" ) +__assign_str (progname,"unknown" ); __entry->version =0 ; - __assign_str(procedure, "unknown") +__assign_str (procedure,"unknown" ); } __entry->requested = requested; __entry->end = xdr->end;
@@ -735,9 +735,9 @@ TRACE_EVENT(rpc_xdr_alignment, __entry->task_id = task->tk_pid; __entry->client_id = task->tk_client->cl_clid;__assign_str (progname, - task->tk_client->cl_program->name) + task->tk_client->cl_program->name); __entry->version = task->tk_client->cl_vers; -__assign_str (procedure, task->tk_msg.rpc_proc->p_name) +__assign_str (procedure, task->tk_msg.rpc_proc->p_name); __entry->offset = offset; __entry->copied = copied;
@@ -1107,9 +1107,9 @@ TRACE_EVENT(xprt_retransmit, __entry->xid =be32_to_cpu (rqst->rq_xid); __entry->ntrans = rqst->rq_ntrans;__assign_str (progname, - task->tk_client->cl_program->name) + task->tk_client->cl_program->name); __entry->version = task->tk_client->cl_vers; -__assign_str (procedure, task->tk_msg.rpc_proc->p_name) +__assign_str (procedure, task->tk_msg.rpc_proc->p_name); ), TP_printk(
@@ -1842,7 +1842,7 @@ TRACE_EVENT(svc_xprt_accept,TP_fast_assign ( __assign_str(addr, xprt->xpt_remotebuf); - __assign_str(protocol, xprt->xpt_class->xcl_name) +__assign_str (protocol, xprt->xpt_class->xcl_name);__assign_str (service, service); ),
net/mac80211/trace.h +1 -1
@@ -33,7 +33,7 @@ __string(vif_name, sdata->name)#define VIF_ASSIGN __entry->vif_type = sdata->vif.type; __entry->sdata = sdata; \ __entry->p2p = sdata->vif.p2p; \ - __assign_str(vif_name, sdata->name) + __assign_str(vif_name, sdata->name);#define VIF_PR_FMT " vif:%s(%d%s)"#define VIF_PR_ARG __get_str(vif_name), __entry->vif_type, __entry->p2p ? "/p2p" : ""
PATCH 1/1 treewide: Add missing semicolons to __assign_str uses
In reply to Steven RostedtThe __assign_str macro has an unusual ending semicolon but the vast majority of uses of the macro already have semicolon termination.
$ git grep -P '\b__assign_str\b' | wc -l 551 $ git grep -P '\b__assign_str\b.*;' | wc -l 480
Add semicolons to the __assign_str() uses without semicolon termination and all the other uses without semicolon termination via additional defines that are equivalent to __assign_str() with the eventual goal of removing the semicolon from the __assign_str() macro definition.
---
Resending without all the direct cc's, only the mailing lists as it seems not to have gone through via vger.
Compiled x84-64 allyesconfig
Quoted 3 lines · Steven Rostedt
I have no problem taking a clean up patch that adds semicolons to all use cases of "
__assign_str()" and ever remove the one from where it is defined. As long as it doesn't break any builds, I'm fine with that.
Removing the semicolon from the macro definition is left for another patch.
drivers/gpu/drm/amd/amdgpu/amdgpu_trace.h | 14 ++++---- drivers/gpu/drm/lima/lima_trace.h | 2 +- drivers/infiniband/hw/hfi1/trace_misc.h | 4 +-- drivers/infiniband/hw/hfi1/trace_rc.h | 4 +-- drivers/infiniband/hw/hfi1/trace_tid.h | 6 ++-- drivers/infiniband/hw/hfi1/trace_tx.h | 8 ++--- drivers/infiniband/sw/rdmavt/trace_cq.h | 4 +-- drivers/infiniband/sw/rdmavt/trace_mr.h | 2 +- drivers/infiniband/sw/rdmavt/trace_qp.h | 4 +-- drivers/infiniband/sw/rdmavt/trace_rc.h | 2 +- drivers/infiniband/sw/rdmavt/trace_tx.h | 4 +-- drivers/misc/mei/mei-trace.h | 6 ++-- .../net/ethernet/marvell/octeontx2/af/rvu_trace.h | 12 +++---- drivers/net/fjes/fjes_trace.h | 4 +-- drivers/usb/cdns3/cdnsp-trace.h | 2 +- fs/nfs/nfs4trace.h | 6 ++-- fs/nfs/nfstrace.h | 4 +-- include/trace/events/btrfs.h | 2 +- include/trace/events/dma_fence.h | 4 +-- include/trace/events/rpcgss.h | 4 +-- include/trace/events/sunrpc.h | 40 +++++++++++----------- net/mac80211/trace.h | 2 +- 22 files changed, 70 insertions(+), 70 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_trace.h +7 -7
@@ -176,10 +176,10 @@ TRACE_EVENT(amdgpu_cs_ioctl,TP_fast_assign ( __entry->sched_job_id = job->base.id; -__assign_str (timeline,AMDGPU_JOB_GET_TIMELINE_NAME (job)) +__assign_str (timeline,AMDGPU_JOB_GET_TIMELINE_NAME (job)); __entry->context = job->base.s_fence->finished.context; __entry->seqno = job->base.s_fence->finished.seqno; -__assign_str (ring,to_amdgpu_ring (job->base.sched)->name) +__assign_str (ring,to_amdgpu_ring (job->base.sched)->name); __entry->num_ibs = job->num_ibs; ), TP_printk("sched_job=%llu, timeline=%s, context=%u, seqno=%u, ring_name=%s, num_ibs=%u",
@@ -201,10 +201,10 @@ TRACE_EVENT(amdgpu_sched_run_job,TP_fast_assign ( __entry->sched_job_id = job->base.id; -__assign_str (timeline,AMDGPU_JOB_GET_TIMELINE_NAME (job)) +__assign_str (timeline,AMDGPU_JOB_GET_TIMELINE_NAME (job)); __entry->context = job->base.s_fence->finished.context; __entry->seqno = job->base.s_fence->finished.seqno; -__assign_str (ring,to_amdgpu_ring (job->base.sched)->name) +__assign_str (ring,to_amdgpu_ring (job->base.sched)->name); __entry->num_ibs = job->num_ibs; ), TP_printk("sched_job=%llu, timeline=%s, context=%u, seqno=%u, ring_name=%s, num_ibs=%u",
@@ -229,7 +229,7 @@ TRACE_EVENT(amdgpu_vm_grab_id,TP_fast_assign ( __entry->pasid = vm->pasid; -__assign_str (ring, ring->name) +__assign_str (ring, ring->name); __entry->vmid = job->vmid; __entry->vm_hub = ring->funcs->vmhub, __entry->pd_addr = job->vm_pd_addr;
@@ -424,7 +424,7 @@ TRACE_EVENT(amdgpu_vm_flush, ), TP_fast_assign( -__assign_str (ring, ring->name) + __assign_str(ring, ring->name); __entry->vmid = vmid; __entry->vm_hub = ring->funcs->vmhub; __entry->pd_addr = pd_addr;
@@ -525,7 +525,7 @@ TRACE_EVENT(amdgpu_ib_pipe_sync, ),TP_fast_assign ( -__assign_str (ring, sched_job->base.sched->name) + __assign_str(ring, sched_job->base.sched->name); __entry->id = sched_job->base.id; __entry->fence = fence; __entry->ctx = fence->context;
drivers/gpu/drm/lima/lima_trace.h +1 -1
@@ -24,7 +24,7 @@ DECLARE_EVENT_CLASS(lima_task, __entry->task_id = task->base.id; __entry->context = task->base.s_fence->finished.context; __entry->seqno = task->base.s_fence->finished.seqno; -__assign_str (pipe, task->base.sched->name) +__assign_str (pipe, task->base.sched->name); ), TP_printk("task=%llu, context=%u seqno=%u pipe=%s",
drivers/infiniband/hw/hfi1/trace_misc.h +2 -2
@@ -63,7 +63,7 @@ TRACE_EVENT(hfi1_interrupt, __array(char, buf, 64)__field (int, src) ), -TP_fast_assign (DD_DEV_ASSIGN (dd) + TP_fast_assign(DD_DEV_ASSIGN(dd); is_entry->is_name (__entry->buf,64 , src - is_entry->start); __entry->src = src;
@@ -100,7 +100,7 @@ TRACE_EVENT(hfi1_fault_opcode, __field(u32, qpn)__field (u8, opcode) ), -TP_fast_assign (DD_DEV_ASSIGN (dd_from_ibdev (qp->ibqp.device)) + TP_fast_assign(DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device)); __entry->qpn = qp->ibqp.qp_num; __entry->opcode = opcode; ),
drivers/infiniband/hw/hfi1/trace_rc.h +2 -2
@@ -70,7 +70,7 @@ DECLARE_EVENT_CLASS(hfi1_rc_template,__field (u32, r_psn) ),TP_fast_assign ( -DD_DEV_ASSIGN (dd_from_ibdev (qp->ibqp.device)) + DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device)); __entry->qpn = qp->ibqp.qp_num; __entry->s_flags = qp->s_flags; __entry->psn = psn;
@@ -130,7 +130,7 @@ DECLARE_EVENT_CLASS(/* rc_ack */__field (u32, lpsn) ),TP_fast_assign (/* assign */ -DD_DEV_ASSIGN (dd_from_ibdev (qp->ibqp.device)) + DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device)); __entry->qpn = qp->ibqp.qp_num; __entry->aeth = aeth; __entry->psn = psn;
drivers/infiniband/hw/hfi1/trace_tid.h +3 -3
@@ -886,7 +886,7 @@ DECLARE_EVENT_CLASS(/* sender_info */__field (u8, s_retry) ),TP_fast_assign (/* assign */ -DD_DEV_ASSIGN (dd_from_ibdev (qp->ibqp.device)) + DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device)); __entry->qpn = qp->ibqp.qp_num; __entry->state = qp->state; __entry->s_cur = qp->s_cur;
@@ -1285,7 +1285,7 @@ DECLARE_EVENT_CLASS(/* rc_rcv_err */__field (int, diff) ),TP_fast_assign (/* assign */ -DD_DEV_ASSIGN (dd_from_ibdev (qp->ibqp.device)) + DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device)); __entry->qpn = qp->ibqp.qp_num; __entry->s_flags = qp->s_flags; __entry->state = qp->state;
@@ -1574,7 +1574,7 @@ DECLARE_EVENT_CLASS(/* tid_ack */__field (u32, resync_psn) ),TP_fast_assign (/* assign */ -DD_DEV_ASSIGN (dd_from_ibdev (qp->ibqp.device)) + DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device)); __entry->qpn = qp->ibqp.qp_num; __entry->aeth = aeth; __entry->psn = psn;
drivers/infiniband/hw/hfi1/trace_tx.h +4 -4
@@ -120,7 +120,7 @@ DECLARE_EVENT_CLASS(hfi1_qpsleepwakeup_template, __field(unsigned long, iow_flags) ),TP_fast_assign ( - DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device)) + DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device)); __entry->flags = flags; __entry->qpn = qp->ibqp.qp_num; __entry->s_flags = qp->s_flags;
@@ -868,7 +868,7 @@ TRACE_EVENT(__field (int, send_flags) ),TP_fast_assign ( -DD_DEV_ASSIGN (dd_from_ibdev (qp->ibqp.device)) + DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device)); __entry->wqe = wqe; __entry->wr_id = wqe->wr.wr_id; __entry->qpn = qp->ibqp.qp_num;
@@ -904,7 +904,7 @@ DECLARE_EVENT_CLASS(__field (bool, flag) ),TP_fast_assign ( -DD_DEV_ASSIGN (dd_from_ibdev (qp->ibqp.device)) + DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device)); __entry->qpn = qp->ibqp.qp_num; __entry->flag = flag; ),
@@ -952,7 +952,7 @@ DECLARE_EVENT_CLASS(/* AIP */__field (u8, stopped) ),TP_fast_assign (/* assign */ -DD_DEV_ASSIGN (txq->priv->dd) + DD_DEV_ASSIGN(txq->priv->dd); __entry->txq = txq; __entry->sde = txq->sde; __entry->head = txq->tx_ring.head;
drivers/infiniband/sw/rdmavt/trace_cq.h +2 -2
@@ -85,7 +85,7 @@ DECLARE_EVENT_CLASS(rvt_cq_template, __field(int, comp_vector_cpu)__field (u32, flags) ), -TP_fast_assign (RDI_DEV_ASSIGN (cq->rdi) + TP_fast_assign(RDI_DEV_ASSIGN(cq->rdi); __entry->ip = cq->ip; __entry->cqe = attr->cqe; __entry->comp_vector = attr->comp_vector;
@@ -123,7 +123,7 @@ DECLARE_EVENT_CLASS(__field (u32, imm) ),TP_fast_assign ( -RDI_DEV_ASSIGN (cq->rdi) + RDI_DEV_ASSIGN(cq->rdi); __entry->wr_id = wc->wr_id; __entry->status = wc->status; __entry->opcode = wc->opcode;
drivers/infiniband/sw/rdmavt/trace_mr.h +1 -1
@@ -195,7 +195,7 @@ TRACE_EVENT(__field (uint, sg_offset) ),TP_fast_assign ( -RDI_DEV_ASSIGN (ib_to_rvt (to_imr (ibmr)->mr.pd->device)) + RDI_DEV_ASSIGN(ib_to_rvt(to_imr(ibmr)->mr.pd->device)); __entry->ibmr_iova = ibmr->iova; __entry->iova =to_imr (ibmr)->mr.iova; __entry->user_base =to_imr (ibmr)->mr.user_base;
drivers/infiniband/sw/rdmavt/trace_qp.h +2 -2
@@ -65,7 +65,7 @@ DECLARE_EVENT_CLASS(rvt_qphash_template,__field (u32, bucket) ),TP_fast_assign ( -RDI_DEV_ASSIGN (ib_to_rvt (qp->ibqp.device)) + RDI_DEV_ASSIGN(ib_to_rvt(qp->ibqp.device)); __entry->qpn = qp->ibqp.qp_num; __entry->bucket = bucket; ),
@@ -97,7 +97,7 @@ DECLARE_EVENT_CLASS(__field (u32, to) ),TP_fast_assign ( -RDI_DEV_ASSIGN (ib_to_rvt (qp->ibqp.device)) + RDI_DEV_ASSIGN(ib_to_rvt(qp->ibqp.device)); __entry->qpn = qp->ibqp.qp_num; __entry->hrtimer = &qp->s_rnr_timer; __entry->s_flags = qp->s_flags;
drivers/infiniband/sw/rdmavt/trace_rc.h +1 -1
@@ -71,7 +71,7 @@ DECLARE_EVENT_CLASS(rvt_rc_template,__field (u32, r_psn) ),TP_fast_assign ( -RDI_DEV_ASSIGN (ib_to_rvt (qp->ibqp.device)) + RDI_DEV_ASSIGN(ib_to_rvt(qp->ibqp.device)); __entry->qpn = qp->ibqp.qp_num; __entry->s_flags = qp->s_flags; __entry->psn = psn;
drivers/infiniband/sw/rdmavt/trace_tx.h +2 -2
@@ -111,7 +111,7 @@ TRACE_EVENT(__field (int, wr_num_sge) ),TP_fast_assign ( -RDI_DEV_ASSIGN (ib_to_rvt (qp->ibqp.device)) + RDI_DEV_ASSIGN(ib_to_rvt(qp->ibqp.device)); __entry->wqe = wqe; __entry->wr_id = wqe->wr.wr_id; __entry->qpn = qp->ibqp.qp_num;
@@ -170,7 +170,7 @@ TRACE_EVENT(__field (int, send_flags) ),TP_fast_assign ( -RDI_DEV_ASSIGN (ib_to_rvt (qp->ibqp.device)) + RDI_DEV_ASSIGN(ib_to_rvt(qp->ibqp.device)); __entry->wqe = wqe; __entry->wr_id = wqe->wr.wr_id; __entry->qpn = qp->ibqp.qp_num;
drivers/misc/mei/mei-trace.h +3 -3
@@ -26,7 +26,7 @@ TRACE_EVENT(mei_reg_read,__field (u32, val) ),TP_fast_assign ( -__assign_str (dev,dev_name (dev)) + __assign_str(dev, dev_name(dev)); __entry->reg = reg; __entry->offs = offs; __entry->val = val;
@@ -45,7 +45,7 @@ TRACE_EVENT(mei_reg_write,__field (u32, val) ),TP_fast_assign ( -__assign_str (dev,dev_name (dev)) + __assign_str(dev, dev_name(dev)); __entry->reg = reg; __entry->offs = offs; __entry->val = val;
@@ -64,7 +64,7 @@ TRACE_EVENT(mei_pci_cfg_read,__field (u32, val) ),TP_fast_assign ( -__assign_str (dev,dev_name (dev)) + __assign_str(dev, dev_name(dev)); __entry->reg = reg; __entry->offs = offs; __entry->val = val;
drivers/net/ethernet/marvell/octeontx2/af/rvu_trace.h +6 -6
@@ -21,7 +21,7 @@ TRACE_EVENT(otx2_msg_alloc, __field(u16, id)__field (u64, size) ), -TP_fast_assign (__assign_str (dev,pci_name (pdev)) + TP_fast_assign(__assign_str(dev, pci_name(pdev)); __entry->id = id; __entry->size = size; ),
@@ -36,7 +36,7 @@ TRACE_EVENT(otx2_msg_send, __field(u16, num_msgs)__field (u64, msg_size) ), -TP_fast_assign (__assign_str (dev,pci_name (pdev)) + TP_fast_assign(__assign_str(dev, pci_name(pdev)); __entry->num_msgs = num_msgs; __entry->msg_size = msg_size; ),
@@ -52,7 +52,7 @@ TRACE_EVENT(otx2_msg_check, __field(u16, rspid)__field (int, rc) ), -TP_fast_assign (__assign_str (dev,pci_name (pdev)) + TP_fast_assign(__assign_str(dev, pci_name(pdev)); __entry->reqid = reqid; __entry->rspid = rspid; __entry->rc = rc;
@@ -69,8 +69,8 @@ TRACE_EVENT(otx2_msg_interrupt, __string(str, msg)__field (u64, intr) ), - TP_fast_assign(__assign_str(dev, pci_name(pdev)) - __assign_str(str, msg) + TP_fast_assign(__assign_str(dev, pci_name(pdev)); +__assign_str (str, msg); __entry->intr = intr; ), TP_printk("[%s] mbox interrupt %s (0x%llx)\n", __get_str(dev),
@@ -84,7 +84,7 @@ TRACE_EVENT(otx2_msg_process, __field(u16, id)__field (int, err) ), -TP_fast_assign (__assign_str (dev,pci_name (pdev)) + TP_fast_assign(__assign_str(dev, pci_name(pdev)); __entry->id = id; __entry->err = err; ),
drivers/net/fjes/fjes_trace.h +2 -2
@@ -232,7 +232,7 @@ TRACE_EVENT(fjes_hw_start_debug_err,__string (err, err) ),TP_fast_assign ( -__assign_str (err, err) + __assign_str(err, err); ),TP_printk ("%s" ,__get_str (err)) );
@@ -258,7 +258,7 @@ TRACE_EVENT(fjes_hw_stop_debug_err,__string (err, err) ),TP_fast_assign ( -__assign_str (err, err) + __assign_str(err, err); ),TP_printk ("%s" ,__get_str (err)) );
drivers/usb/cdns3/cdnsp-trace.h +1 -1
@@ -138,7 +138,7 @@ DECLARE_EVENT_CLASS(cdnsp_log_simple,__string (text, msg) ),TP_fast_assign ( -__assign_str (text, msg) + __assign_str(text, msg); ),TP_printk ("%s" ,__get_str (text)) );
fs/nfs/nfs4trace.h +3 -3
@@ -625,7 +625,7 @@ TRACE_EVENT(nfs4_state_mgr,TP_fast_assign ( __entry->state = clp->cl_state; -__assign_str (hostname, clp->cl_hostname) +__assign_str (hostname, clp->cl_hostname); ), TP_printk(
@@ -1637,7 +1637,7 @@ DECLARE_EVENT_CLASS(nfs4_inode_callback_event, __entry->fileid =0 ; __entry->dev =0 ; } -__assign_str (dstaddr, clp ? clp->cl_hostname :"unknown" ) +__assign_str (dstaddr, clp ? clp->cl_hostname :"unknown" ); ), TP_printk(
@@ -1694,7 +1694,7 @@ DECLARE_EVENT_CLASS(nfs4_inode_stateid_callback_event, __entry->fileid =0 ; __entry->dev =0 ; } -__assign_str (dstaddr, clp ? clp->cl_hostname :"unknown" ) +__assign_str (dstaddr, clp ? clp->cl_hostname :"unknown" ); __entry->stateid_seq =be32_to_cpu (stateid->seqid); __entry->stateid_hash =
fs/nfs/nfstrace.h +2 -2
@@ -1431,8 +1431,8 @@ DECLARE_EVENT_CLASS(nfs_xdr_event, __entry->version = task->tk_client->cl_vers; __entry->error = error;__assign_str (program, - task->tk_client->cl_program->name) -__assign_str (procedure, task->tk_msg.rpc_proc->p_name) + task->tk_client->cl_program->name); +__assign_str (procedure, task->tk_msg.rpc_proc->p_name); ), TP_printk(
include/trace/events/btrfs.h +1 -1
@@ -1093,7 +1093,7 @@ TRACE_EVENT(btrfs_trigger_flush, __entry->flags = flags; __entry->bytes = bytes; __entry->flush = flush; -__assign_str (reason, reason) +__assign_str (reason, reason); ), TP_printk_btrfs("%s: flush=%d(%s) flags=%llu(%s) bytes=%llu",
include/trace/events/dma_fence.h +2 -2
@@ -23,8 +23,8 @@ DECLARE_EVENT_CLASS(dma_fence, ),TP_fast_assign ( - __assign_str(driver, fence->ops->get_driver_name(fence)) - __assign_str(timeline, fence->ops->get_timeline_name(fence)) + __assign_str(driver, fence->ops->get_driver_name(fence)); +__assign_str (timeline, fence->ops->get_timeline_name (fence)); __entry->context = fence->context; __entry->seqno = fence->seqno; ),
include/trace/events/rpcgss.h +2 -2
@@ -152,7 +152,7 @@ DECLARE_EVENT_CLASS(rpcgss_ctx_class,TP_fast_assign ( __entry->cred = gc; __entry->service = gc->gc_service; -__assign_str (principal, gc->gc_principal) +__assign_str (principal, gc->gc_principal); ), TP_printk("cred=%p service=%s principal='%s'",
@@ -535,7 +535,7 @@ TRACE_EVENT(rpcgss_upcall_msg, ),TP_fast_assign ( -__assign_str (msg, buf) + __assign_str(msg, buf); ),TP_printk ("msg='%s'" ,__get_str (msg))
include/trace/events/sunrpc.h +20 -20
@@ -154,8 +154,8 @@ TRACE_EVENT(rpc_clnt_new, __entry->client_id = clnt->cl_clid;__assign_str (addr, xprt->address_strings[RPC_DISPLAY_ADDR ]);__assign_str (port, xprt->address_strings[RPC_DISPLAY_PORT ]); - __assign_str(program, program) -__assign_str (server, server) +__assign_str (program, program); +__assign_str (server, server); ), TP_printk("client=%u peer=[%s]:%s program=%s server=%s",
@@ -180,8 +180,8 @@ TRACE_EVENT(rpc_clnt_new_err,TP_fast_assign ( __entry->error = error; - __assign_str(program, program) -__assign_str (server, server) +__assign_str (program, program); +__assign_str (server, server); ), TP_printk("program=%s server=%s error=%d",
@@ -284,8 +284,8 @@ TRACE_EVENT(rpc_request, __entry->client_id = task->tk_client->cl_clid; __entry->version = task->tk_client->cl_vers; __entry->async =RPC_IS_ASYNC (task); - __assign_str(progname, task->tk_client->cl_program->name) -__assign_str (procname,rpc_proc_name (task)) +__assign_str (progname, task->tk_client->cl_program->name); +__assign_str (procname,rpc_proc_name (task)); ), TP_printk("task:%u@%u %sv%d %s (%ssync)",
@@ -494,10 +494,10 @@ DECLARE_EVENT_CLASS(rpc_reply_event, __entry->task_id = task->tk_pid; __entry->client_id = task->tk_client->cl_clid; __entry->xid =be32_to_cpu (task->tk_rqstp->rq_xid); -__assign_str (progname, task->tk_client->cl_program->name) +__assign_str (progname, task->tk_client->cl_program->name); __entry->version = task->tk_client->cl_vers; - __assign_str(procname, rpc_proc_name(task)) -__assign_str (servername, task->tk_xprt->servername) +__assign_str (procname,rpc_proc_name (task)); +__assign_str (servername, task->tk_xprt->servername); ), TP_printk("task:%u@%d server=%s xid=0x%08x %sv%d %s",
@@ -622,8 +622,8 @@ TRACE_EVENT(rpc_stats_latency, __entry->task_id = task->tk_pid; __entry->xid =be32_to_cpu (task->tk_rqstp->rq_xid); __entry->version = task->tk_client->cl_vers; - __assign_str(progname, task->tk_client->cl_program->name) -__assign_str (procname,rpc_proc_name (task)) +__assign_str (progname, task->tk_client->cl_program->name); +__assign_str (procname,rpc_proc_name (task)); __entry->backlog =ktime_to_us (backlog); __entry->rtt =ktime_to_us (rtt); __entry->execute =ktime_to_us (execute);
@@ -669,15 +669,15 @@ TRACE_EVENT(rpc_xdr_overflow, __entry->task_id = task->tk_pid; __entry->client_id = task->tk_client->cl_clid;__assign_str (progname, - task->tk_client->cl_program->name) + task->tk_client->cl_program->name); __entry->version = task->tk_client->cl_vers; - __assign_str(procedure, task->tk_msg.rpc_proc->p_name) +__assign_str (procedure, task->tk_msg.rpc_proc->p_name); }else { __entry->task_id =0 ; __entry->client_id =0 ; -__assign_str (progname,"unknown" ) +__assign_str (progname,"unknown" ); __entry->version =0 ; - __assign_str(procedure, "unknown") +__assign_str (procedure,"unknown" ); } __entry->requested = requested; __entry->end = xdr->end;
@@ -735,9 +735,9 @@ TRACE_EVENT(rpc_xdr_alignment, __entry->task_id = task->tk_pid; __entry->client_id = task->tk_client->cl_clid;__assign_str (progname, - task->tk_client->cl_program->name) + task->tk_client->cl_program->name); __entry->version = task->tk_client->cl_vers; -__assign_str (procedure, task->tk_msg.rpc_proc->p_name) +__assign_str (procedure, task->tk_msg.rpc_proc->p_name); __entry->offset = offset; __entry->copied = copied;
@@ -1107,9 +1107,9 @@ TRACE_EVENT(xprt_retransmit, __entry->xid =be32_to_cpu (rqst->rq_xid); __entry->ntrans = rqst->rq_ntrans;__assign_str (progname, - task->tk_client->cl_program->name) + task->tk_client->cl_program->name); __entry->version = task->tk_client->cl_vers; -__assign_str (procedure, task->tk_msg.rpc_proc->p_name) +__assign_str (procedure, task->tk_msg.rpc_proc->p_name); ), TP_printk(
@@ -1842,7 +1842,7 @@ TRACE_EVENT(svc_xprt_accept,TP_fast_assign ( __assign_str(addr, xprt->xpt_remotebuf); - __assign_str(protocol, xprt->xpt_class->xcl_name) +__assign_str (protocol, xprt->xpt_class->xcl_name);__assign_str (service, service); ),
net/mac80211/trace.h +1 -1
@@ -33,7 +33,7 @@ __string(vif_name, sdata->name)#define VIF_ASSIGN __entry->vif_type = sdata->vif.type; __entry->sdata = sdata; \ __entry->p2p = sdata->vif.p2p; \ - __assign_str(vif_name, sdata->name) + __assign_str(vif_name, sdata->name);#define VIF_PR_FMT " vif:%s(%d%s)"#define VIF_PR_ARG __get_str(vif_name), __entry->vif_type, __entry->p2p ? "/p2p" : ""
Re: [PATCH] treewide: Add missing semicolons to __assign_str uses
Quoted 8 lines · Joe Perches
The
__assign_strmacro has an unusual ending semicolon but the vast majority of uses of the macro already have semicolon termination.$ git grep -P '\b__assign_str\b' | wc -l 551 $ git grep -P '\b__assign_str\b.*;' | wc -l 480
Quoted 4 lines
Add semicolons to the
__assign_str()uses without semicolon termination and all the other uses without semicolon termination via additional defines that are equivalent to__assign_str()with the eventual goal of removing the semicolon from the__assign_str()macro definition.
Jason
PATCH v2 1/1 treewide: Add missing semicolons to __assign_str uses
In reply to Steven RostedtThe __assign_str macro has an unusual ending semicolon but the vast majority of uses of the macro already have semicolon termination.
$ git grep -P '\b__assign_str\b' | wc -l 551 $ git grep -P '\b__assign_str\b.*;' | wc -l 480
Add semicolons to the __assign_str() uses without semicolon termination and all the other uses without semicolon termination via additional defines that are equivalent to __assign_str() with the eventual goal of removing the semicolon from the __assign_str() macro definition.
---
V2: Remove semicolon addition to #define VIF_ASSIGN as every use of
this macro already has a semicolon termination.
Compiled x84-64 allyesconfig
drivers/gpu/drm/amd/amdgpu/amdgpu_trace.h | 14 ++++---- drivers/gpu/drm/lima/lima_trace.h | 2 +- drivers/infiniband/hw/hfi1/trace_misc.h | 4 +-- drivers/infiniband/hw/hfi1/trace_rc.h | 4 +-- drivers/infiniband/hw/hfi1/trace_tid.h | 6 ++-- drivers/infiniband/hw/hfi1/trace_tx.h | 8 ++--- drivers/infiniband/sw/rdmavt/trace_cq.h | 4 +-- drivers/infiniband/sw/rdmavt/trace_mr.h | 2 +- drivers/infiniband/sw/rdmavt/trace_qp.h | 4 +-- drivers/infiniband/sw/rdmavt/trace_rc.h | 2 +- drivers/infiniband/sw/rdmavt/trace_tx.h | 4 +-- drivers/misc/mei/mei-trace.h | 6 ++-- .../net/ethernet/marvell/octeontx2/af/rvu_trace.h | 12 +++---- drivers/net/fjes/fjes_trace.h | 4 +-- drivers/usb/cdns3/cdnsp-trace.h | 2 +- fs/nfs/nfs4trace.h | 6 ++-- fs/nfs/nfstrace.h | 4 +-- include/trace/events/btrfs.h | 2 +- include/trace/events/dma_fence.h | 4 +-- include/trace/events/rpcgss.h | 4 +-- include/trace/events/sunrpc.h | 40 +++++++++++----------- 21 files changed, 69 insertions(+), 69 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_trace.h +7 -7
@@ -176,10 +176,10 @@ TRACE_EVENT(amdgpu_cs_ioctl,TP_fast_assign ( __entry->sched_job_id = job->base.id; -__assign_str (timeline,AMDGPU_JOB_GET_TIMELINE_NAME (job)) +__assign_str (timeline,AMDGPU_JOB_GET_TIMELINE_NAME (job)); __entry->context = job->base.s_fence->finished.context; __entry->seqno = job->base.s_fence->finished.seqno; -__assign_str (ring,to_amdgpu_ring (job->base.sched)->name) +__assign_str (ring,to_amdgpu_ring (job->base.sched)->name); __entry->num_ibs = job->num_ibs; ), TP_printk("sched_job=%llu, timeline=%s, context=%u, seqno=%u, ring_name=%s, num_ibs=%u",
@@ -201,10 +201,10 @@ TRACE_EVENT(amdgpu_sched_run_job,TP_fast_assign ( __entry->sched_job_id = job->base.id; -__assign_str (timeline,AMDGPU_JOB_GET_TIMELINE_NAME (job)) +__assign_str (timeline,AMDGPU_JOB_GET_TIMELINE_NAME (job)); __entry->context = job->base.s_fence->finished.context; __entry->seqno = job->base.s_fence->finished.seqno; -__assign_str (ring,to_amdgpu_ring (job->base.sched)->name) +__assign_str (ring,to_amdgpu_ring (job->base.sched)->name); __entry->num_ibs = job->num_ibs; ), TP_printk("sched_job=%llu, timeline=%s, context=%u, seqno=%u, ring_name=%s, num_ibs=%u",
@@ -229,7 +229,7 @@ TRACE_EVENT(amdgpu_vm_grab_id,TP_fast_assign ( __entry->pasid = vm->pasid; -__assign_str (ring, ring->name) +__assign_str (ring, ring->name); __entry->vmid = job->vmid; __entry->vm_hub = ring->funcs->vmhub, __entry->pd_addr = job->vm_pd_addr;
@@ -424,7 +424,7 @@ TRACE_EVENT(amdgpu_vm_flush, ), TP_fast_assign( -__assign_str (ring, ring->name) + __assign_str(ring, ring->name); __entry->vmid = vmid; __entry->vm_hub = ring->funcs->vmhub; __entry->pd_addr = pd_addr;
@@ -525,7 +525,7 @@ TRACE_EVENT(amdgpu_ib_pipe_sync, ),TP_fast_assign ( -__assign_str (ring, sched_job->base.sched->name) + __assign_str(ring, sched_job->base.sched->name); __entry->id = sched_job->base.id; __entry->fence = fence; __entry->ctx = fence->context;
drivers/gpu/drm/lima/lima_trace.h +1 -1
@@ -24,7 +24,7 @@ DECLARE_EVENT_CLASS(lima_task, __entry->task_id = task->base.id; __entry->context = task->base.s_fence->finished.context; __entry->seqno = task->base.s_fence->finished.seqno; -__assign_str (pipe, task->base.sched->name) +__assign_str (pipe, task->base.sched->name); ), TP_printk("task=%llu, context=%u seqno=%u pipe=%s",
drivers/infiniband/hw/hfi1/trace_misc.h +2 -2
@@ -63,7 +63,7 @@ TRACE_EVENT(hfi1_interrupt, __array(char, buf, 64)__field (int, src) ), -TP_fast_assign (DD_DEV_ASSIGN (dd) + TP_fast_assign(DD_DEV_ASSIGN(dd); is_entry->is_name (__entry->buf,64 , src - is_entry->start); __entry->src = src;
@@ -100,7 +100,7 @@ TRACE_EVENT(hfi1_fault_opcode, __field(u32, qpn)__field (u8, opcode) ), -TP_fast_assign (DD_DEV_ASSIGN (dd_from_ibdev (qp->ibqp.device)) + TP_fast_assign(DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device)); __entry->qpn = qp->ibqp.qp_num; __entry->opcode = opcode; ),
drivers/infiniband/hw/hfi1/trace_rc.h +2 -2
@@ -70,7 +70,7 @@ DECLARE_EVENT_CLASS(hfi1_rc_template,__field (u32, r_psn) ),TP_fast_assign ( -DD_DEV_ASSIGN (dd_from_ibdev (qp->ibqp.device)) + DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device)); __entry->qpn = qp->ibqp.qp_num; __entry->s_flags = qp->s_flags; __entry->psn = psn;
@@ -130,7 +130,7 @@ DECLARE_EVENT_CLASS(/* rc_ack */__field (u32, lpsn) ),TP_fast_assign (/* assign */ -DD_DEV_ASSIGN (dd_from_ibdev (qp->ibqp.device)) + DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device)); __entry->qpn = qp->ibqp.qp_num; __entry->aeth = aeth; __entry->psn = psn;
drivers/infiniband/hw/hfi1/trace_tid.h +3 -3
@@ -886,7 +886,7 @@ DECLARE_EVENT_CLASS(/* sender_info */__field (u8, s_retry) ),TP_fast_assign (/* assign */ -DD_DEV_ASSIGN (dd_from_ibdev (qp->ibqp.device)) + DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device)); __entry->qpn = qp->ibqp.qp_num; __entry->state = qp->state; __entry->s_cur = qp->s_cur;
@@ -1285,7 +1285,7 @@ DECLARE_EVENT_CLASS(/* rc_rcv_err */__field (int, diff) ),TP_fast_assign (/* assign */ -DD_DEV_ASSIGN (dd_from_ibdev (qp->ibqp.device)) + DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device)); __entry->qpn = qp->ibqp.qp_num; __entry->s_flags = qp->s_flags; __entry->state = qp->state;
@@ -1574,7 +1574,7 @@ DECLARE_EVENT_CLASS(/* tid_ack */__field (u32, resync_psn) ),TP_fast_assign (/* assign */ -DD_DEV_ASSIGN (dd_from_ibdev (qp->ibqp.device)) + DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device)); __entry->qpn = qp->ibqp.qp_num; __entry->aeth = aeth; __entry->psn = psn;
drivers/infiniband/hw/hfi1/trace_tx.h +4 -4
@@ -120,7 +120,7 @@ DECLARE_EVENT_CLASS(hfi1_qpsleepwakeup_template, __field(unsigned long, iow_flags) ),TP_fast_assign ( - DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device)) + DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device)); __entry->flags = flags; __entry->qpn = qp->ibqp.qp_num; __entry->s_flags = qp->s_flags;
@@ -868,7 +868,7 @@ TRACE_EVENT(__field (int, send_flags) ),TP_fast_assign ( -DD_DEV_ASSIGN (dd_from_ibdev (qp->ibqp.device)) + DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device)); __entry->wqe = wqe; __entry->wr_id = wqe->wr.wr_id; __entry->qpn = qp->ibqp.qp_num;
@@ -904,7 +904,7 @@ DECLARE_EVENT_CLASS(__field (bool, flag) ),TP_fast_assign ( -DD_DEV_ASSIGN (dd_from_ibdev (qp->ibqp.device)) + DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device)); __entry->qpn = qp->ibqp.qp_num; __entry->flag = flag; ),
@@ -952,7 +952,7 @@ DECLARE_EVENT_CLASS(/* AIP */__field (u8, stopped) ),TP_fast_assign (/* assign */ -DD_DEV_ASSIGN (txq->priv->dd) + DD_DEV_ASSIGN(txq->priv->dd); __entry->txq = txq; __entry->sde = txq->sde; __entry->head = txq->tx_ring.head;
drivers/infiniband/sw/rdmavt/trace_cq.h +2 -2
@@ -85,7 +85,7 @@ DECLARE_EVENT_CLASS(rvt_cq_template, __field(int, comp_vector_cpu)__field (u32, flags) ), -TP_fast_assign (RDI_DEV_ASSIGN (cq->rdi) + TP_fast_assign(RDI_DEV_ASSIGN(cq->rdi); __entry->ip = cq->ip; __entry->cqe = attr->cqe; __entry->comp_vector = attr->comp_vector;
@@ -123,7 +123,7 @@ DECLARE_EVENT_CLASS(__field (u32, imm) ),TP_fast_assign ( -RDI_DEV_ASSIGN (cq->rdi) + RDI_DEV_ASSIGN(cq->rdi); __entry->wr_id = wc->wr_id; __entry->status = wc->status; __entry->opcode = wc->opcode;
drivers/infiniband/sw/rdmavt/trace_mr.h +1 -1
@@ -195,7 +195,7 @@ TRACE_EVENT(__field (uint, sg_offset) ),TP_fast_assign ( -RDI_DEV_ASSIGN (ib_to_rvt (to_imr (ibmr)->mr.pd->device)) + RDI_DEV_ASSIGN(ib_to_rvt(to_imr(ibmr)->mr.pd->device)); __entry->ibmr_iova = ibmr->iova; __entry->iova =to_imr (ibmr)->mr.iova; __entry->user_base =to_imr (ibmr)->mr.user_base;
drivers/infiniband/sw/rdmavt/trace_qp.h +2 -2
@@ -65,7 +65,7 @@ DECLARE_EVENT_CLASS(rvt_qphash_template,__field (u32, bucket) ),TP_fast_assign ( -RDI_DEV_ASSIGN (ib_to_rvt (qp->ibqp.device)) + RDI_DEV_ASSIGN(ib_to_rvt(qp->ibqp.device)); __entry->qpn = qp->ibqp.qp_num; __entry->bucket = bucket; ),
@@ -97,7 +97,7 @@ DECLARE_EVENT_CLASS(__field (u32, to) ),TP_fast_assign ( -RDI_DEV_ASSIGN (ib_to_rvt (qp->ibqp.device)) + RDI_DEV_ASSIGN(ib_to_rvt(qp->ibqp.device)); __entry->qpn = qp->ibqp.qp_num; __entry->hrtimer = &qp->s_rnr_timer; __entry->s_flags = qp->s_flags;
drivers/infiniband/sw/rdmavt/trace_rc.h +1 -1
@@ -71,7 +71,7 @@ DECLARE_EVENT_CLASS(rvt_rc_template,__field (u32, r_psn) ),TP_fast_assign ( -RDI_DEV_ASSIGN (ib_to_rvt (qp->ibqp.device)) + RDI_DEV_ASSIGN(ib_to_rvt(qp->ibqp.device)); __entry->qpn = qp->ibqp.qp_num; __entry->s_flags = qp->s_flags; __entry->psn = psn;
drivers/infiniband/sw/rdmavt/trace_tx.h +2 -2
@@ -111,7 +111,7 @@ TRACE_EVENT(__field (int, wr_num_sge) ),TP_fast_assign ( -RDI_DEV_ASSIGN (ib_to_rvt (qp->ibqp.device)) + RDI_DEV_ASSIGN(ib_to_rvt(qp->ibqp.device)); __entry->wqe = wqe; __entry->wr_id = wqe->wr.wr_id; __entry->qpn = qp->ibqp.qp_num;
@@ -170,7 +170,7 @@ TRACE_EVENT(__field (int, send_flags) ),TP_fast_assign ( -RDI_DEV_ASSIGN (ib_to_rvt (qp->ibqp.device)) + RDI_DEV_ASSIGN(ib_to_rvt(qp->ibqp.device)); __entry->wqe = wqe; __entry->wr_id = wqe->wr.wr_id; __entry->qpn = qp->ibqp.qp_num;
drivers/misc/mei/mei-trace.h +3 -3
@@ -26,7 +26,7 @@ TRACE_EVENT(mei_reg_read,__field (u32, val) ),TP_fast_assign ( -__assign_str (dev,dev_name (dev)) + __assign_str(dev, dev_name(dev)); __entry->reg = reg; __entry->offs = offs; __entry->val = val;
@@ -45,7 +45,7 @@ TRACE_EVENT(mei_reg_write,__field (u32, val) ),TP_fast_assign ( -__assign_str (dev,dev_name (dev)) + __assign_str(dev, dev_name(dev)); __entry->reg = reg; __entry->offs = offs; __entry->val = val;
@@ -64,7 +64,7 @@ TRACE_EVENT(mei_pci_cfg_read,__field (u32, val) ),TP_fast_assign ( -__assign_str (dev,dev_name (dev)) + __assign_str(dev, dev_name(dev)); __entry->reg = reg; __entry->offs = offs; __entry->val = val;
drivers/net/ethernet/marvell/octeontx2/af/rvu_trace.h +6 -6
@@ -21,7 +21,7 @@ TRACE_EVENT(otx2_msg_alloc, __field(u16, id)__field (u64, size) ), -TP_fast_assign (__assign_str (dev,pci_name (pdev)) + TP_fast_assign(__assign_str(dev, pci_name(pdev)); __entry->id = id; __entry->size = size; ),
@@ -36,7 +36,7 @@ TRACE_EVENT(otx2_msg_send, __field(u16, num_msgs)__field (u64, msg_size) ), -TP_fast_assign (__assign_str (dev,pci_name (pdev)) + TP_fast_assign(__assign_str(dev, pci_name(pdev)); __entry->num_msgs = num_msgs; __entry->msg_size = msg_size; ),
@@ -52,7 +52,7 @@ TRACE_EVENT(otx2_msg_check, __field(u16, rspid)__field (int, rc) ), -TP_fast_assign (__assign_str (dev,pci_name (pdev)) + TP_fast_assign(__assign_str(dev, pci_name(pdev)); __entry->reqid = reqid; __entry->rspid = rspid; __entry->rc = rc;
@@ -69,8 +69,8 @@ TRACE_EVENT(otx2_msg_interrupt, __string(str, msg)__field (u64, intr) ), - TP_fast_assign(__assign_str(dev, pci_name(pdev)) - __assign_str(str, msg) + TP_fast_assign(__assign_str(dev, pci_name(pdev)); +__assign_str (str, msg); __entry->intr = intr; ), TP_printk("[%s] mbox interrupt %s (0x%llx)\n", __get_str(dev),
@@ -84,7 +84,7 @@ TRACE_EVENT(otx2_msg_process, __field(u16, id)__field (int, err) ), -TP_fast_assign (__assign_str (dev,pci_name (pdev)) + TP_fast_assign(__assign_str(dev, pci_name(pdev)); __entry->id = id; __entry->err = err; ),
drivers/net/fjes/fjes_trace.h +2 -2
@@ -232,7 +232,7 @@ TRACE_EVENT(fjes_hw_start_debug_err,__string (err, err) ),TP_fast_assign ( -__assign_str (err, err) + __assign_str(err, err); ),TP_printk ("%s" ,__get_str (err)) );
@@ -258,7 +258,7 @@ TRACE_EVENT(fjes_hw_stop_debug_err,__string (err, err) ),TP_fast_assign ( -__assign_str (err, err) + __assign_str(err, err); ),TP_printk ("%s" ,__get_str (err)) );
drivers/usb/cdns3/cdnsp-trace.h +1 -1
@@ -138,7 +138,7 @@ DECLARE_EVENT_CLASS(cdnsp_log_simple,__string (text, msg) ),TP_fast_assign ( -__assign_str (text, msg) + __assign_str(text, msg); ),TP_printk ("%s" ,__get_str (text)) );
fs/nfs/nfs4trace.h +3 -3
@@ -625,7 +625,7 @@ TRACE_EVENT(nfs4_state_mgr,TP_fast_assign ( __entry->state = clp->cl_state; -__assign_str (hostname, clp->cl_hostname) +__assign_str (hostname, clp->cl_hostname); ), TP_printk(
@@ -1637,7 +1637,7 @@ DECLARE_EVENT_CLASS(nfs4_inode_callback_event, __entry->fileid =0 ; __entry->dev =0 ; } -__assign_str (dstaddr, clp ? clp->cl_hostname :"unknown" ) +__assign_str (dstaddr, clp ? clp->cl_hostname :"unknown" ); ), TP_printk(
@@ -1694,7 +1694,7 @@ DECLARE_EVENT_CLASS(nfs4_inode_stateid_callback_event, __entry->fileid =0 ; __entry->dev =0 ; } -__assign_str (dstaddr, clp ? clp->cl_hostname :"unknown" ) +__assign_str (dstaddr, clp ? clp->cl_hostname :"unknown" ); __entry->stateid_seq =be32_to_cpu (stateid->seqid); __entry->stateid_hash =
fs/nfs/nfstrace.h +2 -2
@@ -1423,8 +1423,8 @@ DECLARE_EVENT_CLASS(nfs_xdr_event, __entry->version = task->tk_client->cl_vers; __entry->error = error;__assign_str (program, - task->tk_client->cl_program->name) -__assign_str (procedure, task->tk_msg.rpc_proc->p_name) + task->tk_client->cl_program->name); +__assign_str (procedure, task->tk_msg.rpc_proc->p_name); ), TP_printk(
include/trace/events/btrfs.h +1 -1
@@ -1093,7 +1093,7 @@ TRACE_EVENT(btrfs_trigger_flush, __entry->flags = flags; __entry->bytes = bytes; __entry->flush = flush; -__assign_str (reason, reason) +__assign_str (reason, reason); ), TP_printk_btrfs("%s: flush=%d(%s) flags=%llu(%s) bytes=%llu",
include/trace/events/dma_fence.h +2 -2
@@ -23,8 +23,8 @@ DECLARE_EVENT_CLASS(dma_fence, ),TP_fast_assign ( - __assign_str(driver, fence->ops->get_driver_name(fence)) - __assign_str(timeline, fence->ops->get_timeline_name(fence)) + __assign_str(driver, fence->ops->get_driver_name(fence)); +__assign_str (timeline, fence->ops->get_timeline_name (fence)); __entry->context = fence->context; __entry->seqno = fence->seqno; ),
include/trace/events/rpcgss.h +2 -2
@@ -152,7 +152,7 @@ DECLARE_EVENT_CLASS(rpcgss_ctx_class,TP_fast_assign ( __entry->cred = gc; __entry->service = gc->gc_service; -__assign_str (principal, gc->gc_principal) +__assign_str (principal, gc->gc_principal); ), TP_printk("cred=%p service=%s principal='%s'",
@@ -535,7 +535,7 @@ TRACE_EVENT(rpcgss_upcall_msg, ),TP_fast_assign ( -__assign_str (msg, buf) + __assign_str(msg, buf); ),TP_printk ("msg='%s'" ,__get_str (msg))
include/trace/events/sunrpc.h +20 -20
@@ -154,8 +154,8 @@ TRACE_EVENT(rpc_clnt_new, __entry->client_id = clnt->cl_clid;__assign_str (addr, xprt->address_strings[RPC_DISPLAY_ADDR ]);__assign_str (port, xprt->address_strings[RPC_DISPLAY_PORT ]); - __assign_str(program, program) -__assign_str (server, server) +__assign_str (program, program); +__assign_str (server, server); ), TP_printk("client=%u peer=[%s]:%s program=%s server=%s",
@@ -180,8 +180,8 @@ TRACE_EVENT(rpc_clnt_new_err,TP_fast_assign ( __entry->error = error; - __assign_str(program, program) -__assign_str (server, server) +__assign_str (program, program); +__assign_str (server, server); ), TP_printk("program=%s server=%s error=%d",
@@ -284,8 +284,8 @@ TRACE_EVENT(rpc_request, __entry->client_id = task->tk_client->cl_clid; __entry->version = task->tk_client->cl_vers; __entry->async =RPC_IS_ASYNC (task); - __assign_str(progname, task->tk_client->cl_program->name) -__assign_str (procname,rpc_proc_name (task)) +__assign_str (progname, task->tk_client->cl_program->name); +__assign_str (procname,rpc_proc_name (task)); ), TP_printk("task:%u@%u %sv%d %s (%ssync)",
@@ -494,10 +494,10 @@ DECLARE_EVENT_CLASS(rpc_reply_event, __entry->task_id = task->tk_pid; __entry->client_id = task->tk_client->cl_clid; __entry->xid =be32_to_cpu (task->tk_rqstp->rq_xid); -__assign_str (progname, task->tk_client->cl_program->name) +__assign_str (progname, task->tk_client->cl_program->name); __entry->version = task->tk_client->cl_vers; - __assign_str(procname, rpc_proc_name(task)) -__assign_str (servername, task->tk_xprt->servername) +__assign_str (procname,rpc_proc_name (task)); +__assign_str (servername, task->tk_xprt->servername); ), TP_printk("task:%u@%d server=%s xid=0x%08x %sv%d %s",
@@ -622,8 +622,8 @@ TRACE_EVENT(rpc_stats_latency, __entry->task_id = task->tk_pid; __entry->xid =be32_to_cpu (task->tk_rqstp->rq_xid); __entry->version = task->tk_client->cl_vers; - __assign_str(progname, task->tk_client->cl_program->name) -__assign_str (procname,rpc_proc_name (task)) +__assign_str (progname, task->tk_client->cl_program->name); +__assign_str (procname,rpc_proc_name (task)); __entry->backlog =ktime_to_us (backlog); __entry->rtt =ktime_to_us (rtt); __entry->execute =ktime_to_us (execute);
@@ -669,15 +669,15 @@ TRACE_EVENT(rpc_xdr_overflow, __entry->task_id = task->tk_pid; __entry->client_id = task->tk_client->cl_clid;__assign_str (progname, - task->tk_client->cl_program->name) + task->tk_client->cl_program->name); __entry->version = task->tk_client->cl_vers; - __assign_str(procedure, task->tk_msg.rpc_proc->p_name) +__assign_str (procedure, task->tk_msg.rpc_proc->p_name); }else { __entry->task_id =0 ; __entry->client_id =0 ; -__assign_str (progname,"unknown" ) +__assign_str (progname,"unknown" ); __entry->version =0 ; - __assign_str(procedure, "unknown") +__assign_str (procedure,"unknown" ); } __entry->requested = requested; __entry->end = xdr->end;
@@ -735,9 +735,9 @@ TRACE_EVENT(rpc_xdr_alignment, __entry->task_id = task->tk_pid; __entry->client_id = task->tk_client->cl_clid;__assign_str (progname, - task->tk_client->cl_program->name) + task->tk_client->cl_program->name); __entry->version = task->tk_client->cl_vers; -__assign_str (procedure, task->tk_msg.rpc_proc->p_name) +__assign_str (procedure, task->tk_msg.rpc_proc->p_name); __entry->offset = offset; __entry->copied = copied;
@@ -1107,9 +1107,9 @@ TRACE_EVENT(xprt_retransmit, __entry->xid =be32_to_cpu (rqst->rq_xid); __entry->ntrans = rqst->rq_ntrans;__assign_str (progname, - task->tk_client->cl_program->name) + task->tk_client->cl_program->name); __entry->version = task->tk_client->cl_vers; -__assign_str (procedure, task->tk_msg.rpc_proc->p_name) +__assign_str (procedure, task->tk_msg.rpc_proc->p_name); ), TP_printk(
@@ -1842,7 +1842,7 @@ TRACE_EVENT(svc_xprt_accept,TP_fast_assign ( __assign_str(addr, xprt->xpt_remotebuf); - __assign_str(protocol, xprt->xpt_class->xcl_name) +__assign_str (protocol, xprt->xpt_class->xcl_name);__assign_str (service, service); ),
Steven Rostedt
maintainerRe: [PATCH V2] treewide: Add missing semicolons to __assign_str uses
Quoted 8 lines · On Sat, 12 Jun 2021 08:42:27 -0700 Joe Perches <[email protected]> wrote:
The
__assign_strmacro has an unusual ending semicolon but the vast majority of uses of the macro already have semicolon termination.$ git grep -P '\b__assign_str\b' | wc -l 551 $ git grep -P '\b__assign_str\b.*;' | wc -l 480
Quoted 6 lines
Add semicolons to the
__assign_str()uses without semicolon termination and all the other uses without semicolon termination via additional defines that are equivalent to__assign_str()with the eventual goal of removing the semicolon from the__assign_str()macro definition.
FYI, please send new patches as new threads. Otherwise it is likely to be missed.
-- Steve
Re: [PATCH V2] treewide: Add missing semicolons to __assign_str uses
In reply to Joe PerchesQuoted 2 lines · Joe Perches
The
__assign_strmacro has an unusual ending semicolon but the vast majority of uses of the macro already have semicolon termination.
ping?
Steven Rostedt
maintainerRe: [PATCH V2] treewide: Add missing semicolons to __assign_str uses
Quoted 6 lines · On Wed, 30 Jun 2021 04:28:39 -0700 Joe Perches <[email protected]> wrote:
Quoted 2 lines · Joe Perches
The
__assign_strmacro has an unusual ending semicolon but the vast majority of uses of the macro already have semicolon termination.ping?
I wasn't sure I was the one to take this. I can, as I can run tests on it as well. I have some last minute fixes sent to me on something else, and I can apply this along with them.
-- Steve
Re: [PATCH V3 7/9] tracing: Add __print_ns_to_secs() and __print_ns_without_secs() helpers
In reply to Steven RostedtQuoted 36 lines · Steven Rostedt
include/trace/trace_events.h TRACE_MAKE_SYSTEM_STR(); · line 367
Quoted 12 lines · On Fri, 14 May 2021 22:51:16 +0200 Daniel Bristot de Oliveira…
+++
b/include/trace/trace_events.hinclude/trace/trace_events.h +7
-0@@ -358,6 +358,21 @@ TRACE_MAKE_SYSTEM_STR();trace_print_hex_dump_seq (p, prefix_str, prefix_type, \ rowsize, groupsize, buf, len, ascii) +#undef __print_ns_to_secs +#define __print_ns_to_secs (value) \ + ({ \ + u64 ____val = (u64)value; \ + do_div(____val, NSEC_PER_SEC); \ + ____val; \ + })I know my name is on this, but we need parenthesis around "value".
include/trace/trace_events.h TRACE_MAKE_SYSTEM_STR(); · line 372
Quoted 5 lines
include/trace/trace_events.h +5
-0+ +#undef __print_ns_without_secs +#define __print_ns_without_secs (value) \ + ({ \ + u64 ____val = (u64)value; \Here too.
Quoted 10 lines
include/trace/trace_events.h +3
-0+ (u32 )do_div (____val,NSEC_PER_SEC ); \ + }) +#undef DECLARE_EVENT_CLASS#define DECLARE_EVENT_CLASS (call, proto, args, tstruct, assign, print) \ static notrace enum print_line_t \@@ -736,6 +751,16 @@ static inline void ftrace_test_probe_##call(void) \#undef __print_array#undef __print_hex_dump
Quoted 11 lines
include/trace/trace_events.h static inline void ftrace_test_probe_##call(void) \ · line 762
Quoted 9 lines
include/trace/trace_events.h +9
-0+/* +* The below is not executed in the kernel. It is only what is +* displayed in the print format for userspace to parse. +*/ +#undef __print_ns_to_secs +#define __print_ns_to_secs (val) val / 1000000000UL + +#undef __print_ns_without_secs +#define __print_ns_without_secs (val) val % 1000000000ULAnd around "val" in the above two macros.
Fixing in the v4.
Thanks Steven!
-- Daniel
Quoted 7 lines
-- Steve
Quoted 4 lines
include/trace/trace_events.h +1
-0+#undef TP_printk #define TP_printk(fmt, args...) "\"" fmt "\", " __stringify(args)
PATCH v3 8/9 tracing: Add osnoise tracer
In reply to Daniel Bristot de OliveiraIn the context of high-performance computing (HPC), the Operating System Noise (*osnoise*) refers to the interference experienced by an application due to activities inside the operating system. In the context of Linux, NMIs, IRQs, SoftIRQs, and any other system thread can cause noise to the system. Moreover, hardware-related jobs can also cause noise, for example, via SMIs.
The osnoise tracer leverages the hwlat_detector by running a similar loop with preemption, SoftIRQs and IRQs enabled, thus allowing all the sources of *osnoise* during its execution. Using the same approach of hwlat, osnoise takes note of the entry and exit point of any source of interferences, increasing a per-cpu interference counter. The osnoise tracer also saves an interference counter for each source of interference. The interference counter for NMI, IRQs, SoftIRQs, and threads is increased anytime the tool observes these interferences' entry events. When a noise happens without any interference from the operating system level, the hardware noise counter increases, pointing to a hardware-related noise. In this way, osnoise can account for any source of interference. At the end of the period, the osnoise tracer prints the sum of all noise, the max single noise, the percentage of CPU available for the thread, and the counters for the noise sources.
Usage
Write the ASCII text "osnoise" into the current_tracer file of the tracing system (generally mounted at /sys/kernel/tracing).
For example::
[root@f32 ~]# cd /sys/kernel/tracing/ [root@f32 tracing]# echo osnoise > current_tracer
It is possible to follow the trace by reading the trace trace file::
[root@f32 tracing]# cat trace
# tracer: osnoise
#
# _-----=> irqs-off
# / _----=> need-resched
# | / _---=> hardirq/softirq
# || / _--=> preempt-depth MAX
# || / SINGLE Interference counters:
# |||| RUNTIME NOISE % OF CPU NOISE +-----------------------------+
# TASK-PID CPU# |||| TIMESTAMP IN US IN US AVAILABLE IN US HW NMI IRQ SIRQ THREAD
# | | | |||| | | | | | | | | | |
<...>-859 [000] .... 81.637220: 1000000 190 99.98100 9 18 0 1007 18 1
<...>-860 [001] .... 81.638154: 1000000 656 99.93440 74 23 0 1006 16 3
<...>-861 [002] .... 81.638193: 1000000 5675 99.43250 202 6 0 1013 25 21
<...>-862 [003] .... 81.638242: 1000000 125 99.98750 45 1 0 1011 23 0
<...>-863 [004] .... 81.638260: 1000000 1721 99.82790 168 7 0 1002 49 41
<...>-864 [005] .... 81.638286: 1000000 263 99.97370 57 6 0 1006 26 2
<...>-865 [006] .... 81.638302: 1000000 109 99.98910 21 3 0 1006 18 1
<...>-866 [007] .... 81.638326: 1000000 7816 99.21840 107 8 0 1016 39 19In addition to the regular trace fields (from TASK-PID to TIMESTAMP), the tracer prints a message at the end of each period for each CPU that is running an osnoise/CPU thread. The osnoise specific fields report:
- The RUNTIME IN USE reports the amount of time in microseconds that the osnoise thread kept looping reading the time.
- The NOISE IN US reports the sum of noise in microseconds observed by the osnoise tracer during the associated runtime.
- The % OF CPU AVAILABLE reports the percentage of CPU available for the osnoise thread during the runtime window.
- The MAX SINGLE NOISE IN US reports the maximum single noise observed during the runtime window.
- The Interference counters display how many each of the respective interference happened during the runtime window.
Note that the example above shows a high number of HW noise samples. The reason being is that this sample was taken on a virtual machine, and the host interference is detected as a hardware interference.
Tracer options
The tracer has a set of options inside the osnoise directory, they are:
- osnoise/cpus: CPUs at which a osnoise thread will execute.
- osnoise/period_us: the period of the osnoise thread.
- osnoise/runtime_us: how long an osnoise thread will look for noise.
- osnoise/stop_tracing_in_us: stop the system tracing if a single noise higher than the configured value happens. Writing 0 disables this option.
- osnoise/stop_tracing_out_us: stop the system tracing if total noise higher than the configured value happens. Writing 0 disables this option.
- tracing_threshold: the minimum delta between two time() reads to be considered as noise, in us. When set to 0, the minimum valid value will be used, which is currently 1 us.
Additional Tracing
In addition to the tracer, a set of tracepoints were added to facilitate the identification of the osnoise source.
- osnoise:sample_threshold: printed anytime a noise is higher than the configurable tolerance_ns.
- osnoise:nmi_noise: noise from NMI, including the duration.
- osnoise:irq_noise: noise from an IRQ, including the duration.
- osnoise:softirq_noise: noise from a SoftIRQ, including the duration.
- osnoise:thread_noise: noise from a thread, including the duration.
Note that all the values are *net values*. For example, if while osnoise is running, another thread preempts the osnoise thread, it will start a thread_noise duration at the start. Then, an IRQ takes place, preempting the thread_noise, starting a irq_noise. When the IRQ ends its execution, it will compute its duration, and this duration will be subtracted from the thread_noise, in such a way as to avoid the double accounting of the IRQ execution. This logic is valid for all sources of noise.
Here is one example of the usage of these tracepoints::
osnoise/8-961 [008] d.h. 5789.857532: irq_noise: local_timer:236 start 5789.857529929 duration 1845 ns
osnoise/8-961 [008] dNh. 5789.858408: irq_noise: local_timer:236 start 5789.858404871 duration 2848 ns
migration/8-54 [008] d... 5789.858413: thread_noise: migration/8:54 start 5789.858409300 duration 3068 ns
osnoise/8-961 [008] .... 5789.858413: sample_threshold: start 5789.858404555 duration 8723 ns interferences 2In this example, a noise sample of 8 microseconds was reported in the last line, pointing to two interferences. Looking backward in the trace, the two previous entries were about the migration thread running after a timer IRQ execution. The first event is not part of the noise because it took place one millisecond before.
It is worth noticing that the sum of the duration reported in the tracepoints is smaller than eight us reported in the sample_threshold. The reason roots in the overhead of the entry and exit code that happens before and after any interference execution. This justifies the dual
approach: measuring thread and tracing.
--- Documentation/trace/index.rst | 1 + Documentation/trace/osnoise-tracer.rst | 152 +++ include/linux/ftrace_irq.h | 13 + include/trace/events/osnoise.h | 142 +++ kernel/trace/Kconfig | 34 + kernel/trace/Makefile | 1 + kernel/trace/trace.h | 9 +- kernel/trace/trace_entries.h | 25 + kernel/trace/trace_osnoise.c | 1563 ++++++++++++++++++++++++ kernel/trace/trace_output.c | 72 +- 10 files changed, 2008 insertions(+), 4 deletions(-) create mode 100644 Documentation/trace/osnoise-tracer.rst create mode 100644 include/trace/events/osnoise.h create mode 100644 kernel/trace/trace_osnoise.c
Documentation/trace/index.rst +1 -0
@@ -23,6 +23,7 @@ Linux Tracing Technologies histogram-design boottime-trace hwlat_detector + osnoise-tracer intel_th ring-buffer-design stm
Documentation/trace/osnoise-tracer.rst new file +152 -0
152 lines not on this page · raw message
include/linux/ftrace_irq.h +13 -0
@@ -7,12 +7,21 @@ extern bool trace_hwlat_callback_enabled;extern void trace_hwlat_callback (bool enter);#endif +#ifdef CONFIG_OSNOISE_TRACER +extern bool trace_osnoise_callback_enabled; +extern void trace_osnoise_callback (bool enter); +#endif +static inline void ftrace_nmi_enter (void ) {#ifdef CONFIG_HWLAT_TRACER if (trace_hwlat_callback_enabled)trace_hwlat_callback (true);#endif +#ifdef CONFIG_OSNOISE_TRACER +if (trace_osnoise_callback_enabled) +trace_osnoise_callback (true); +#endif }static inline void ftrace_nmi_exit (void )
@@ -21,6 +30,10 @@ static inline void ftrace_nmi_exit(void)if (trace_hwlat_callback_enabled)trace_hwlat_callback (false);#endif +#ifdef CONFIG_OSNOISE_TRACER +if (trace_osnoise_callback_enabled) +trace_osnoise_callback (false); +#endif }#endif /* _LINUX_FTRACE_IRQ_H */
include/trace/events/osnoise.h new file +142 -0
142 lines not on this page · raw message
kernel/trace/Kconfig +34 -0
@@ -356,6 +356,40 @@ config HWLAT_TRACER file. Every time a latency is greater than tracing_thresh, it will be recorded into the ring buffer. +config OSNOISE_TRACER + bool "OS Noise tracer" + select GENERIC_TRACER + help + In the context of high-performance computing (HPC), the Operating + System Noise (osnoise) refers to the interference experienced by an + application due to activities inside the operating system. In the + context of Linux, NMIs, IRQs, SoftIRQs, and any other system thread + can cause noise to the system. Moreover, hardware-related jobs can + also cause noise, for example, via SMIs. + + The osnoise tracer leverages the hwlat_detector by running a similar + loop with preemption, SoftIRQs and IRQs enabled, thus allowing all + the sources of osnoise during its execution. The osnoise tracer takes + note of the entry and exit point of any source of interferences, + increasing a per-cpu interference counter. It saves an interference + counter for each source of interference. The interference counter for + NMI, IRQs, SoftIRQs, and threads is increased anytime the tool + observes these interferences' entry events. When a noise happens + without any interference from the operating system level, the + hardware noise counter increases, pointing to a hardware-related + noise. In this way, osnoise can account for any source of + interference. At the end of the period, the osnoise tracer prints + the sum of all noise, the max single noise, the percentage of CPU + available for the thread, and the counters for the noise sources. + + In addition to the tracer, a set of tracepoints were added to + facilitate the identification of the osnoise source. + + The output will appear in the trace and trace_pipe files. + + To enable this tracer, echo in "osnoise" into the current_tracer + file. + config MMIOTRACE bool "Memory mapped IO tracing" depends on HAVE_MMIOTRACE_SUPPORT && PCI
kernel/trace/Makefile +1 -0
@@ -58,6 +58,7 @@ obj-$(CONFIG_IRQSOFF_TRACER) += trace_irqsoff.o obj-$(CONFIG_PREEMPT_TRACER) += trace_irqsoff.o obj-$(CONFIG_SCHED_TRACER) += trace_sched_wakeup.o obj-$(CONFIG_HWLAT_TRACER) += trace_hwlat.o +obj-$(CONFIG_OSNOISE_TRACER) += trace_osnoise.o obj-$(CONFIG_NOP_TRACER) += trace_nop.o obj-$(CONFIG_STACK_TRACER) += trace_stack.o obj-$(CONFIG_MMIOTRACE) += trace_mmiotrace.o
kernel/trace/trace.h +6 -3
@@ -44,6 +44,7 @@ enum trace_type {TRACE_BLK ,TRACE_BPUTS ,TRACE_HWLAT , +TRACE_OSNOISE ,TRACE_RAW_DATA , TRACE_FUNC_REPEATS,
@@ -297,7 +298,8 @@ struct trace_array {struct array_buffer max_buffer;bool allocated_snapshot;#endif -#if defined(CONFIG_TRACER_MAX_TRACE ) || defined(CONFIG_HWLAT_TRACER ) +#if defined(CONFIG_TRACER_MAX_TRACE ) || defined(CONFIG_HWLAT_TRACER ) \ + || defined(CONFIG_OSNOISE_TRACER )unsigned long max_latency;#ifdef CONFIG_FSNOTIFY struct dentry *d_max_latency;
@@ -445,6 +447,7 @@ extern void __ftrace_bad_type(void); IF_ASSIGN(var, ent, struct bprint_entry, TRACE_BPRINT); \ IF_ASSIGN(var, ent, struct bputs_entry, TRACE_BPUTS); \ IF_ASSIGN(var, ent, struct hwlat_entry, TRACE_HWLAT); \ + IF_ASSIGN(var, ent, struct osnoise_entry, TRACE_OSNOISE);\ IF_ASSIGN(var, ent, struct raw_data_entry, TRACE_RAW_DATA);\ IF_ASSIGN(var, ent, struct trace_mmiotrace_rw, \TRACE_MMIO_RW ); \
@@ -675,8 +678,8 @@ void update_max_tr_single(struct trace_array *tr, struct task_struct *tsk, int cpu);#endif /* CONFIG_TRACER_MAX_TRACE */ -#if (defined(CONFIG_TRACER_MAX_TRACE ) || defined(CONFIG_HWLAT_TRACER )) && \ - defined(CONFIG_FSNOTIFY ) +#if (defined(CONFIG_TRACER_MAX_TRACE ) || defined(CONFIG_HWLAT_TRACER )) \ + || defined(CONFIG_OSNOISE_TRACER ) && defined(CONFIG_FSNOTIFY )void latency_fsnotify (struct trace_array *tr);
kernel/trace/trace_entries.h +25 -0
@@ -360,3 +360,28 @@ FTRACE_ENTRY(func_repeats, func_repeats_entry, __entry->count, FUNC_REPEATS_GET_DELTA_TS(__entry)) ); + +FTRACE_ENTRY (osnoise, osnoise_entry, + +TRACE_OSNOISE , + +F_STRUCT ( + __field( u64, noise ) + __field( u64, runtime ) + __field( u64, max_sample ) + __field( unsigned int, hw_count ) + __field( unsigned int, nmi_count ) + __field( unsigned int, irq_count ) + __field( unsigned int, softirq_count ) + __field( unsigned int, thread_count ) + ), + +F_printk ("noise:%llu\tmax_sample:%llu\thw:%u\tnmi:%u\tirq:%u\tsoftirq:%u\tthread:%u\n" , + __entry->noise, + __entry->max_sample, + __entry->hw_count, + __entry->nmi_count, + __entry->irq_count, + __entry->softirq_count, + __entry->thread_count) +);
kernel/trace/trace_osnoise.c new file +1563 -0
1,563 lines not on this page · raw message
kernel/trace/trace_output.c +71 -1
90 lines not on this page · raw message
Signature · 1 line
2.26.3
Steven Rostedt
maintainerRe: [PATCH V3 8/9] tracing: Add osnoise tracer
kernel/trace/trace_osnoise.c line 1474
Quoted 7 lines · On Fri, 14 May 2021 22:51:17 +0200 Daniel Bristot de Oliveira…
kernel/trace/trace_osnoise.c new file +7
-0+static void osnoise_tracer_start (struct trace_array *tr) +{ +int retval; + +if (osnoise_busy) +return ; +
I need more time to look at this patch, but "git show" points out that there's a spurious tab in the above line.
-- Steve
Quoted 5 lines
kernel/trace/trace_osnoise.c new file +5
-0+osn_var_reset_all (); + + retval =osnoise_hook_events (); +if (retval) + goto out_err;
Steven Rostedt
maintainerRe: [PATCH V3 8/9] tracing: Add osnoise tracer
In reply to Daniel Bristot de OliveiraQuoted 4 lines · On Fri, 14 May 2021 22:51:17 +0200 Daniel Bristot de Oliveira…
Tracer options
The tracer has a set of options inside the osnoise directory, they are:
Quoted 9 lines
- osnoise/cpus: CPUs at which a osnoise thread will execute.
- osnoise/period_us: the period of the osnoise thread.
- osnoise/runtime_us: how long an osnoise thread will look for noise.
- osnoise/stop_tracing_in_us: stop the system tracing if a single noise higher than the configured value happens. Writing 0 disables this option.
- osnoise/stop_tracing_out_us: stop the system tracing if total noise higher than the configured value happens. Writing 0 disables this option.
The "in" vs "out" is confusing. Perhaps we should call it:
stop_tracing_single_us and stop_tracing_total_us ?
Quoted 117 lines
-
tracing_threshold: the minimum delta between twotime()reads to be considered as noise, in us. When set to 0, the minimum valid value will be used, which is currently 1 us.Additional Tracing
In addition to the tracer, a set of tracepoints were added to facilitate the identification of the osnoise source.
- osnoise:sample_threshold: printed anytime a noise is higher than the configurable
tolerance_ns.
- osnoise:nmi_noise: noise from NMI, including the duration.
- osnoise:irq_noise: noise from an IRQ, including the duration.
- osnoise:softirq_noise: noise from a SoftIRQ, including the duration.
- osnoise:thread_noise: noise from a thread, including the duration.Note that all the values are *net values*. For example, if while osnoise is running, another thread preempts the osnoise thread, it will start a
thread_noiseduration at the start. Then, an IRQ takes place, preempting thethread_noise, starting airq_noise. When the IRQ ends its execution, it will compute its duration, and this duration will be subtracted from thethread_noise, in such a way as to avoid the double accounting of the IRQ execution. This logic is valid for all sources of noise.Here is one example of the usage of these tracepoints::
osnoise/8-961 [008] d.h. 5789.857532: irq_noise: local_timer:236 start 5789.857529929 duration 1845 ns osnoise/8-961 [008] dNh. 5789.858408: irq_noise: local_timer:236 start 5789.858404871 duration 2848 ns migration/8-54 [008] d... 5789.858413: thread_noise: migration/8:54 start 5789.858409300 duration 3068 ns osnoise/8-961 [008] .... 5789.858413: sample_threshold: start 5789.858404555 duration 8723 ns interferences 2In this example, a noise sample of 8 microseconds was reported in the last line, pointing to two interferences. Looking backward in the trace, the two previous entries were about the migration thread running after a timer IRQ execution. The first event is not part of the noise because it took place one millisecond before.
It is worth noticing that the sum of the duration reported in the tracepoints is smaller than eight us reported in the
sample_threshold. The reason roots in the overhead of the entry and exit code that happens before and after any interference execution. This justifies the dual
approach: measuring thread and tracing.kernel/trace/trace_osnoise.c new file +67
-0@@ -0,0 +1,1563 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* OS Noise Tracer: computes the OS Noise suffered by a running thread. +* +* Based on "hwlat_detector" tracer by: +* Copyright (C) 2008-2009 Jon Masters, Red Hat, Inc. <[email protected]> +* Copyright (C) 2013-2016 Steven Rostedt, Red Hat, Inc. <[email protected]> +* With feedback from Clark Williams <[email protected]> +* +* And also based on the rtsl tracer presented on: +* DE OLIVEIRA, Daniel Bristot, et al. Demystifying the real-time linux +* scheduling latency. In: 32nd Euromicro Conference on Real-Time Systems +* (ECRTS 2020). Schloss Dagstuhl-Leibniz-Zentrum fur Informatik, 2020. +* +* Copyright (C) 2021 Daniel Bristot de Oliveira, Red Hat, Inc. <[email protected]> +*/ + +#include <linux/kthread.h> +#include <linux/tracefs.h> +#include <linux/uaccess.h> +#include <linux/cpumask.h> +#include <linux/delay.h> +#include <linux/sched/clock.h> +#include <linux/sched.h> +#include "trace.h" + +#ifdef CONFIG_X86_LOCAL_APIC +#include <asm/trace/irq_vectors.h> +#undef TRACE_INCLUDE_PATH +#undef TRACE_INCLUDE_FILE +#endif /* CONFIG_X86_LOCAL_APIC */ + +#include <trace/events/irq.h> +#include <trace/events/sched.h> + +#define CREATE_TRACE_POINTS +#include <trace/events/osnoise.h> + +static struct trace_array *osnoise_trace; + +/* +* Default values. +*/ +#define BANNER "osnoise: " +#define DEFAULT_SAMPLE_PERIOD 1000000/* 1s */ +#define DEFAULT_SAMPLE_RUNTIME 1000000/* 1s */ + +/* +* NMI runtime info. +*/ +struct nmi { +u64 count; +u64 delta_start; +}; + +/* +* IRQ runtime info. +*/ +struct irq { +u64 count; +u64 arrival_time; +u64 delta_start; +}; + +/* +* SofIRQ runtime info. +*/
kernel/trace/trace_osnoise.c line 77
Quoted 10 lines
kernel/trace/trace_osnoise.c new file +10
-0+struct softirq { +u64 count; +u64 arrival_time; +u64 delta_start; +}; + +/* +* Thread runtime info. +*/ +struct thread {
These are rather generic struct names that could possibly be a conflict to something in the future. I would suggest adding "osn_" or something in front of them:
struct osn_nmi
struct osn_irq
struct osn_thread
or something like that.
Quoted 9 lines
kernel/trace/trace_osnoise.c new file +9
-0+u64 count; +u64 arrival_time; +u64 delta_start; +}; + +/* +* Runtime information: this structure saves the runtime information used by +* one sampling thread. +*/
kernel/trace/trace_osnoise.c line 96
Quoted 10 lines
kernel/trace/trace_osnoise.c new file +10
-0+struct osnoise_variables { +struct task_struct *kthread; +bool sampling; +pid_t pid; +struct nmi nmi; +struct irq irq; +struct softirq softirq; +struct thread thread; +local_t int_counter; +};
Nit, but it looks better to add tabs to the fields:
struct osnoise_variables {
sturct task_struct *kthread;
bool sampling;
pid_t pid;
struct nmi nmi;
struct irq irq;
struct softirq softirq;
struct thread thread;
local_t int_counter;
};See, it's much easier to see the fields of the structure this way.
Quoted 14 lines
kernel/trace/trace_osnoise.c new file +14
-0+ +/* +* Per-cpu runtime information. +*/ +DEFINE_PER_CPU(struct osnoise_variables, per_cpu_osnoise_var); + +/** +* this_cpu_osn_var - Return the per-cpu osnoise_variables on its relative CPU +*/ +static inline struct osnoise_variables *this_cpu_osn_var (void ) +{ +return this_cpu_ptr (&per_cpu_osnoise_var); +} +
kernel/trace/trace_osnoise.c line 120
Quoted 10 lines
kernel/trace/trace_osnoise.c new file +10
-0+/** +* osn_var_reset - Reset the values of the given osnoise_variables +*/ +static inline void osn_var_reset (struct osnoise_variables *osn_var) +{ +/* +* So far, all the values are initialized as 0, so +* zeroing the structure is perfect. +*/ +memset (osn_var,0 ,sizeof (struct osnoise_variables ));
I'm one of those that prefer:
memset(osn_var, 0, sizeof(*osn_var))
Just in case something changes, you don't need to modify the memset.
Quoted 146 lines
kernel/trace/trace_osnoise.c new file +146
-0+} + +/** +* osn_var_reset_all - Reset the value of all per-cpu osnoise_variables +*/ +static inline void osn_var_reset_all (void ) +{ +struct osnoise_variables *osn_var; +int cpu; + +for_each_cpu (cpu, cpu_online_mask) { + osn_var =per_cpu_ptr (&per_cpu_osnoise_var, cpu); +osn_var_reset (osn_var); + } +} + +/* +* Tells NMIs to call back to the osnoise tracer to record timestamps. +*/ +bool trace_osnoise_callback_enabled; + +/* +* osnoise sample structure definition. Used to store the statistics of a +* sample run. +*/ +struct osnoise_sample { +u64 runtime;/* runtime */ +u64 noise;/* noise */ +u64 max_sample;/* max single noise sample */ +int hw_count;/* # HW (incl. hypervisor) interference */ +int nmi_count;/* # NMIs during this sample */ +int irq_count;/* # IRQs during this sample */ +int softirq_count;/* # SoftIRQs during this sample */ +int thread_count;/* # Threads during this sample */ +}; + +/* +* Protect the interface. +*/ +struct mutex interface_lock; + +/* +* Tracer data. +*/ +static struct osnoise_data { +u64 sample_period;/* total sampling period */ +u64 sample_runtime;/* active sampling portion of period */ +u64 stop_tracing_in;/* stop trace in the inside operation (loop) */ +u64 stop_tracing_out;/* stop trace in the outside operation (report) */ +} osnoise_data = { + .sample_period =DEFAULT_SAMPLE_PERIOD , + .sample_runtime =DEFAULT_SAMPLE_RUNTIME , + .stop_tracing_in =0 , + .stop_tracing_out =0 , +}; + +/* +* Boolean variable used to inform that the tracer is currently sampling. +*/ +static bool osnoise_busy; + +/* +* Print the osnoise header info. +*/ +static void print_osnoise_headers (struct seq_file *s) +{ +seq_puts (s,"# _-----=> irqs-off\n" ); +seq_puts (s,"# / _----=> need-resched\n" ); +seq_puts (s,"# | / _---=> hardirq/softirq\n" ); +seq_puts (s,"# || / _--=> preempt-depth " ); +seq_puts (s," MAX\n" ); + +seq_puts (s,"# || / " ); +seq_puts (s," SINGLE Interference counters:\n" ); + +seq_puts (s,"# |||| RUNTIME " ); +seq_puts (s," NOISE %% OF CPU NOISE +-----------------------------+\n" ); + +seq_puts (s,"# TASK-PID CPU# |||| TIMESTAMP IN US " ); +seq_puts (s," IN US AVAILABLE IN US HW NMI IRQ SIRQ THREAD\n" ); + +seq_puts (s,"# | | | |||| | | " ); +seq_puts (s," | | | | | | | |\n" ); +} + +/* +* Record an osnoise_sample into the tracer buffer. +*/ +static void trace_osnoise_sample (struct osnoise_sample *sample) +{ +struct trace_array *tr = osnoise_trace; +struct trace_buffer *buffer = tr->array_buffer.buffer; +struct trace_event_call *call = &event_osnoise; +struct ring_buffer_event *event; +struct osnoise_entry *entry; + + event =trace_buffer_lock_reserve (buffer,TRACE_OSNOISE ,sizeof (*entry), +tracing_gen_ctx ()); +if (!event) +return ; + entry =ring_buffer_event_data (event); + entry->runtime = sample->runtime; + entry->noise = sample->noise; + entry->max_sample = sample->max_sample; + entry->hw_count = sample->hw_count; + entry->nmi_count = sample->nmi_count; + entry->irq_count = sample->irq_count; + entry->softirq_count = sample->softirq_count; + entry->thread_count = sample->thread_count; + +if (!call_filter_check_discard (call, entry, buffer, event)) +trace_buffer_unlock_commit_nostack (buffer, event); +} + +/** +* Macros to encapsulate the time capturing infrastructure. +*/ +#define time_get () trace_clock_local() +#define time_to_us (x) div_u64(x, 1000) +#define time_sub (a, b) ((a) - (b)) + +/** +* cond_move_irq_delta_start - Forward the delta_start of a running IRQ +* +* If an IRQ is preempted by an NMI, its delta_start is pushed forward +* to discount the NMI interference. +* +* See get_int_safe_duration(). +*/ +static inline void +cond_move_irq_delta_start (struct osnoise_variables *osn_var,u64 duration) +{ +if (osn_var->irq.delta_start) + osn_var->irq.delta_start += duration; +} + +#ifndef CONFIG_PREEMPT_RT +/** +* cond_move_softirq_delta_start - Forward the delta_start of a running SoftIRQ +* +* If a SoftIRQ is preempted by an IRQ or NMI, its delta_start is pushed +* forward to discount the interference. +* +* See get_int_safe_duration(). +*/ +static inline void
kernel/trace/trace_osnoise.c line 276
Quoted 10 lines
kernel/trace/trace_osnoise.c new file +10
-0+cond_move_softirq_delta_start(struct osnoise_variables *osn_var, u64 duration) +{ +if (osn_var->softirq.delta_start) + osn_var->softirq.delta_start += duration; +} +#else /* CONFIG_PREEMPT_RT */ +#define cond_move_softirq_delta_start (osn_var, duration) do {} while (0) +#endif + +/**
Don't use the "/**" notation if you are not following kernel doc (which means you need to also document each parameter and return value. The '/**' is usually reserved for non static functions that are an API for other parts of the kernel. Use just '/*' for these (unless you want to add full kernel doc notation).
Quoted 55 lines
kernel/trace/trace_osnoise.c new file +55
-0+* cond_move_thread_delta_start - Forward the delta_start of a running thread +* +* If a noisy thread is preempted by an Softirq, IRQ or NMI, its delta_start +* is pushed forward to discount the interference. +* +* See get_int_safe_duration(). +*/ +static inline void +cond_move_thread_delta_start (struct osnoise_variables *osn_var,u64 duration) +{ +if (osn_var->thread.delta_start) + osn_var->thread.delta_start += duration; +} + +/** +* get_int_safe_duration - Get the duration of a window +* +* The irq, softirq and thread varaibles need to have its duration without +* the interference from higher priority interrupts. Instead of keeping a +* variable to discount the interrupt interference from these variables, the +* starting time of these variables are pushed forward with the interrupt's +* duration. In this way, a single variable is used to: +* +* - Know if a given window is being measured. +* - Account its duration. +* - Discount the interference. +* +* To avoid getting inconsistent values, e.g.,: +* +* now = time_get() +* ---> interrupt! +* delta_start -= int duration; +* <--- +* duration = now - delta_start; +* +* result: negative duration if the variable duration before the +* interrupt was smaller than the interrupt execution. +* +* A counter of interrupts is used. If the counter increased, try +* to capture an interference safe duration. +*/ +static inline s64 +get_int_safe_duration (struct osnoise_variables *osn_var,u64 *delta_start) +{ +u64 int_counter, now; +s64 duration; + + do { + int_counter = local_read(&osn_var->int_counter); + /* synchronize with interrupts */ + barrier(); + + now = time_get(); + duration = (now - *delta_start); +
kernel/trace/trace_osnoise.c line 341
Quoted 10 lines
kernel/trace/trace_osnoise.c new file +10
-0+/* synchronize with interrupts */ +barrier (); + }while (int_counter !=local_read (&osn_var->int_counter)); + +/* +* This is an evidence of race conditions that cause +* a value to be "discounted" too much. +*/ +if (duration <0 ) +pr_err ("int safe negative!\n" );
Probably want to have this happen at most once a run. If something were to break, I don't think we want this to live lock the machine doing tons of prints. We could have a variable stored on the osnoise_variables that states this was printed. Check that variable to see if it wasn't printed during a run (when current_tracer was set), and print only once if it is.
Quoted 16 lines
kernel/trace/trace_osnoise.c new file +16
-0+ + *delta_start =0 ; + +return duration; +} + +/** +* +* set_int_safe_time - Save the current time on *time, aware of interference +* +* Get the time, taking into consideration a possible interference from +* higher priority interrupts. +* +* See get_int_safe_duration() for an explanation. +*/ +static u64
kernel/trace/trace_osnoise.c line 367
Quoted 10 lines
kernel/trace/trace_osnoise.c new file +10
-0+set_int_safe_time(struct osnoise_variables *osn_var, u64 *time) +{ + u64 int_counter; + + do { + int_counter = local_read(&osn_var->int_counter); + /* synchronize with interrupts */ + barrier(); + + *time = time_get();
time_get() is trace_clock_local() which is used in tracing, and should not be affected by interrupts. Why the loop? Even if using the generic NMI-unsafe version of sched_clock, it does its own loop.
Quoted 105 lines
kernel/trace/trace_osnoise.c new file +105
-0+ +/* synchronize with interrupts */ +barrier (); + }while (int_counter !=local_read (&osn_var->int_counter)); + +return int_counter; +} + +/** +* trace_osnoise_callback - NMI entry/exit callback +* +* This function is called at the entry and exit NMI code. The bool enter +* distinguishes between either case. This function is used to note a NMI +* occurrence, compute the noise caused by the NMI, and to remove the noise +* it is potentially causing on other interference variables. +*/ +void trace_osnoise_callback (bool enter) +{ +struct osnoise_variables *osn_var =this_cpu_osn_var (); +u64 duration; + +if (!osn_var->sampling) +return ; + +/* +* Currently trace_clock_local() calls sched_clock() and the +* generic version is not NMI safe. +*/ +if (!IS_ENABLED (CONFIG_GENERIC_SCHED_CLOCK )) { +if (enter) { + osn_var->nmi.delta_start =time_get (); +local_inc (&osn_var->int_counter); + }else { + duration =time_get () - osn_var->nmi.delta_start; + +trace_nmi_noise (osn_var->nmi.delta_start, duration); + +cond_move_irq_delta_start (osn_var, duration); +cond_move_softirq_delta_start (osn_var, duration); +cond_move_thread_delta_start (osn_var, duration); + } + } + +if (enter) + osn_var->nmi.count++; +} + +/** +* __trace_irq_entry - Note the starting of an IRQ +* +* Save the starting time of an IRQ. As IRQs are non-preemptive to other IRQs, +* it is safe to use a single variable (ons_var->irq) to save the statistics. +* The arrival_time is used to report... the arrival time. The delta_start +* is used to compute the duration at the IRQ exit handler. See +* cond_move_irq_delta_start(). +*/ +static inline void __trace_irq_entry (int id) +{ +struct osnoise_variables *osn_var =this_cpu_osn_var (); + +if (!osn_var->sampling) +return ; +/* +* This value will be used in the report, but not to compute +* the execution time, so it is safe to get it unsafe. +*/ + osn_var->irq.arrival_time =time_get (); +set_int_safe_time (osn_var, &osn_var->irq.delta_start); + osn_var->irq.count++; + +local_inc (&osn_var->int_counter); +} + +/** +* __trace_irq_exit - Note the end of an IRQ, sava data and trace +* +* Computes the duration of the IRQ noise, and trace it. Also discounts the +* interference from other sources of noise could be currently being accounted. +*/ +static inline void __trace_irq_exit (int id,const char *desc) +{ +struct osnoise_variables *osn_var =this_cpu_osn_var (); +int duration; + +if (!osn_var->sampling) +return ; + + duration =get_int_safe_duration (osn_var, &osn_var->irq.delta_start); +trace_irq_noise (id, desc, osn_var->irq.arrival_time, duration); + osn_var->irq.arrival_time =0 ; +cond_move_softirq_delta_start (osn_var, duration); +cond_move_thread_delta_start (osn_var, duration); +} + +/** +* trace_irqentry_callback - Callback to the irq:irq_entry traceevent +* +* Used to note the starting of an IRQ occurece. +*/ +void trace_irqentry_callback (void *data,int irq,struct irqaction *action) +{ +__trace_irq_entry (irq); +} + +/**
kernel/trace/trace_osnoise.c line 482
Quoted 10 lines
kernel/trace/trace_osnoise.c new file +10
-0+* trace_irqexit_callback - Callback to the irq:irq_exit traceevent +* +* Used to note the end of an IRQ occurece. +*/ +void trace_irqexit_callback (void *data,int irq,struct irqaction *action,int ret) +{ +__trace_irq_exit (irq, action->name); +} + +#ifdef CONFIG_X86_LOCAL_APIC
I wonder if we should move this into a separate file, making the __trace_irq_entry() a more name space safe name and have it call that. I have a bit of a distaste for arch specific code in a generic file.
Quoted 226 lines
kernel/trace/trace_osnoise.c new file +226
-0+/** +* trace_intel_irq_entry - record intel specific IRQ entry +*/ +void trace_intel_irq_entry (void *data,int vector) +{ +__trace_irq_entry (vector); +} + +/** +* trace_intel_irq_exit - record intel specific IRQ exit +*/ +void trace_intel_irq_exit (void *data,int vector) +{ +char *vector_desc = (char *) data; + +__trace_irq_exit (vector, vector_desc); +} + +/** +* register_intel_irq_tp - Register intel specific IRQ entry tracepoints +*/ +static int register_intel_irq_tp (void ) +{ +int ret; + + ret =register_trace_local_timer_entry (trace_intel_irq_entry,NULL ); +if (ret) + goto out_err; + + ret =register_trace_local_timer_exit (trace_intel_irq_exit,"local_timer" ); +if (ret) + goto out_timer_entry; + +#ifdef CONFIG_X86_THERMAL_VECTOR + ret =register_trace_thermal_apic_entry (trace_intel_irq_entry,NULL ); +if (ret) + goto out_timer_exit; + + ret =register_trace_thermal_apic_exit (trace_intel_irq_exit,"thermal_apic" ); +if (ret) + goto out_thermal_entry; +#endif /* CONFIG_X86_THERMAL_VECTOR */ + +#ifdef CONFIG_X86_MCE_AMD + ret =register_trace_deferred_error_apic_entry (trace_intel_irq_entry,NULL ); +if (ret) + goto out_thermal_exit; + + ret =register_trace_deferred_error_apic_exit (trace_intel_irq_exit,"deferred_error" ); +if (ret) + goto out_deferred_entry; +#endif + +#ifdef CONFIG_X86_MCE_THRESHOLD + ret =register_trace_threshold_apic_entry (trace_intel_irq_entry,NULL ); +if (ret) + goto out_deferred_exit; + + ret =register_trace_threshold_apic_exit (trace_intel_irq_exit,"threshold_apic" ); +if (ret) + goto out_threshold_entry; +#endif /* CONFIG_X86_MCE_THRESHOLD */ + +#ifdef CONFIG_SMP + ret =register_trace_call_function_single_entry (trace_intel_irq_entry,NULL ); +if (ret) + goto out_threshold_exit; + + ret =register_trace_call_function_single_exit (trace_intel_irq_exit, +"call_function_single" ); +if (ret) + goto out_call_function_single_entry; + + ret =register_trace_call_function_entry (trace_intel_irq_entry,NULL ); +if (ret) + goto out_call_function_single_exit; + + ret =register_trace_call_function_exit (trace_intel_irq_exit,"call_function" ); +if (ret) + goto out_call_function_entry; + + ret =register_trace_reschedule_entry (trace_intel_irq_entry,NULL ); +if (ret) + goto out_call_function_exit; + + ret =register_trace_reschedule_exit (trace_intel_irq_exit,"reschedule" ); +if (ret) + goto out_reschedule_entry; +#endif /* CONFIG_SMP */ + +#ifdef CONFIG_IRQ_WORK + ret =register_trace_irq_work_entry (trace_intel_irq_entry,NULL ); +if (ret) + goto out_reschedule_exit; + + ret =register_trace_irq_work_exit (trace_intel_irq_exit,"irq_work" ); +if (ret) + goto out_irq_work_entry; +#endif + + ret =register_trace_x86_platform_ipi_entry (trace_intel_irq_entry,NULL ); +if (ret) + goto out_irq_work_exit; + + ret =register_trace_x86_platform_ipi_exit (trace_intel_irq_exit,"x86_platform_ipi" ); +if (ret) + goto out_x86_ipi_entry; + + ret =register_trace_error_apic_entry (trace_intel_irq_entry,NULL ); +if (ret) + goto out_x86_ipi_exit; + + ret =register_trace_error_apic_exit (trace_intel_irq_exit,"error_apic" ); +if (ret) + goto out_error_apic_entry; + + ret =register_trace_spurious_apic_entry (trace_intel_irq_entry,NULL ); +if (ret) + goto out_error_apic_exit; + + ret =register_trace_spurious_apic_exit (trace_intel_irq_exit,"spurious_apic" ); +if (ret) + goto out_spurious_apic_entry; + +return 0 ; + +out_spurious_apic_entry: +unregister_trace_spurious_apic_entry (trace_intel_irq_entry,NULL ); +out_error_apic_exit: +unregister_trace_error_apic_exit (trace_intel_irq_exit,"error_apic" ); +out_error_apic_entry: +unregister_trace_error_apic_entry (trace_intel_irq_entry,NULL ); +out_x86_ipi_exit: +unregister_trace_x86_platform_ipi_exit (trace_intel_irq_exit,"x86_platform_ipi" ); +out_x86_ipi_entry: +unregister_trace_x86_platform_ipi_entry (trace_intel_irq_entry,NULL ); +out_irq_work_exit: + +#ifdef CONFIG_IRQ_WORK +unregister_trace_irq_work_exit (trace_intel_irq_exit,"irq_work" ); +out_irq_work_entry: +unregister_trace_irq_work_entry (trace_intel_irq_entry,NULL ); +out_reschedule_exit: +#endif + +#ifdef CONFIG_SMP +unregister_trace_reschedule_exit (trace_intel_irq_exit,"reschedule" ); +out_reschedule_entry: +unregister_trace_reschedule_entry (trace_intel_irq_entry,NULL ); +out_call_function_exit: +unregister_trace_call_function_exit (trace_intel_irq_exit,"call_function" ); +out_call_function_entry: +unregister_trace_call_function_entry (trace_intel_irq_entry,NULL ); +out_call_function_single_exit: +unregister_trace_call_function_single_exit (trace_intel_irq_exit,"call_function_single" ); +out_call_function_single_entry: +unregister_trace_call_function_single_entry (trace_intel_irq_entry,NULL ); +out_threshold_exit: +#endif + +#ifdef CONFIG_X86_MCE_THRESHOLD +unregister_trace_threshold_apic_exit (trace_intel_irq_exit,"threshold_apic" ); +out_threshold_entry: +unregister_trace_threshold_apic_entry (trace_intel_irq_entry,NULL ); +out_deferred_exit: +#endif + +#ifdef CONFIG_X86_MCE_AMD +unregister_trace_deferred_error_apic_exit (trace_intel_irq_exit,"deferred_error" ); +out_deferred_entry: +unregister_trace_deferred_error_apic_entry (trace_intel_irq_entry,NULL ); +out_thermal_exit: +#endif /* CONFIG_X86_MCE_AMD */ + +#ifdef CONFIG_X86_THERMAL_VECTOR +unregister_trace_thermal_apic_exit (trace_intel_irq_exit,"thermal_apic" ); +out_thermal_entry: +unregister_trace_thermal_apic_entry (trace_intel_irq_entry,NULL ); +out_timer_exit: +#endif /* CONFIG_X86_THERMAL_VECTOR */ + +unregister_trace_local_timer_exit (trace_intel_irq_exit,"local_timer" ); +out_timer_entry: +unregister_trace_local_timer_entry (trace_intel_irq_entry,NULL ); +out_err: +return -EINVAL ; +} + +static void unregister_intel_irq_tp (void ) +{ +unregister_trace_spurious_apic_exit (trace_intel_irq_exit,"spurious_apic" ); +unregister_trace_spurious_apic_entry (trace_intel_irq_entry,NULL ); +unregister_trace_error_apic_exit (trace_intel_irq_exit,"error_apic" ); +unregister_trace_error_apic_entry (trace_intel_irq_entry,NULL ); +unregister_trace_x86_platform_ipi_exit (trace_intel_irq_exit,"x86_platform_ipi" ); +unregister_trace_x86_platform_ipi_entry (trace_intel_irq_entry,NULL ); + +#ifdef CONFIG_IRQ_WORK +unregister_trace_irq_work_exit (trace_intel_irq_exit,"irq_work" ); +unregister_trace_irq_work_entry (trace_intel_irq_entry,NULL ); +#endif + +#ifdef CONFIG_SMP +unregister_trace_reschedule_exit (trace_intel_irq_exit,"reschedule" ); +unregister_trace_reschedule_entry (trace_intel_irq_entry,NULL ); +unregister_trace_call_function_exit (trace_intel_irq_exit,"call_function" ); +unregister_trace_call_function_entry (trace_intel_irq_entry,NULL ); +unregister_trace_call_function_single_exit (trace_intel_irq_exit,"call_function_single" ); +unregister_trace_call_function_single_entry (trace_intel_irq_entry,NULL ); +#endif + +#ifdef CONFIG_X86_MCE_THRESHOLD +unregister_trace_threshold_apic_exit (trace_intel_irq_exit,"threshold_apic" ); +unregister_trace_threshold_apic_entry (trace_intel_irq_entry,NULL ); +#endif + +#ifdef CONFIG_X86_MCE_AMD +unregister_trace_deferred_error_apic_exit (trace_intel_irq_exit,"deferred_error" ); +unregister_trace_deferred_error_apic_entry (trace_intel_irq_entry,NULL ); +#endif + +#ifdef CONFIG_X86_THERMAL_VECTOR +unregister_trace_thermal_apic_exit (trace_intel_irq_exit,"thermal_apic" ); +unregister_trace_thermal_apic_entry (trace_intel_irq_entry,NULL ); +#endif /* CONFIG_X86_THERMAL_VECTOR */ +
kernel/trace/trace_osnoise.c line 716
Quoted 10 lines
kernel/trace/trace_osnoise.c new file +8
-0+unregister_trace_local_timer_exit (trace_intel_irq_exit,"local_timer" ); + unregister_trace_local_timer_entry(trace_intel_irq_entry, NULL); +} + +#else /* CONFIG_X86_LOCAL_APIC */ +#define register_intel_irq_tp () do {} while (0) +#define unregister_intel_irq_tp () do {} while (0) +#endif /* CONFIG_X86_LOCAL_APIC */
And have this in a local header file. kernel/trace/trace_osnoise.h ?
Quoted 39 lines
kernel/trace/trace_osnoise.c new file +39
-0+ +/** +* hook_irq_events - Hook IRQ handling events +* +* This function hooks the IRQ related callbacks to the respective trace +* events. +*/ +int hook_irq_events (void ) +{ +int ret; + + ret =register_trace_irq_handler_entry (trace_irqentry_callback,NULL ); +if (ret) + goto out_err; + + ret =register_trace_irq_handler_exit (trace_irqexit_callback,NULL ); +if (ret) + goto out_unregister_entry; + + ret =register_intel_irq_tp (); +if (ret) + goto out_irq_exit; + +return 0 ; + +out_irq_exit: +unregister_trace_irq_handler_exit (trace_irqexit_callback,NULL ); +out_unregister_entry: +unregister_trace_irq_handler_entry (trace_irqentry_callback,NULL ); +out_err: +return -EINVAL ; +} + +/** +* unhook_irq_events - Unhook IRQ handling events +* +* This function unhooks the IRQ related callbacks to the respective trace +* events. +*/
kernel/trace/trace_osnoise.c line 765
Quoted 10 lines
kernel/trace/trace_osnoise.c new file +10
-0+void unhook_irq_events (void ) +{ +unregister_intel_irq_tp (); +unregister_trace_irq_handler_exit (trace_irqexit_callback,NULL ); +unregister_trace_irq_handler_entry (trace_irqentry_callback,NULL ); +} + +#ifndef CONFIG_PREEMPT_RT +/** +* trace_softirq_entry_callback - Note the starting of a SoftIRQ
Where did you get the case usage of that. I've never seen it written like "SoftIRQ" in the kernel. Just call it softirq as it is referenced everyplace else.
Quoted 210 lines
+ *
+ * Save the starting time of a SoftIRQ. As SoftIRQs are non-preemptive to
+ * other SoftIRQs, it is safe to use a single variable (ons_var->softirq)
+ * to save the statistics. Thearrival_timeis used to report... the
+ * arrival time. Thedelta_startis used to compute the duration at the
+ * SoftIRQ exit handler. Seecond_move_softirq_delta_start().
+ */kernel/trace/trace_osnoise.c new file +203
-0+void trace_softirq_entry_callback (void *data,unsigned int vec_nr) +{ +struct osnoise_variables *osn_var =this_cpu_osn_var (); + +if (!osn_var->sampling) +return ; +/* +* This value will be used in the report, but not to compute +* the execution time, so it is safe to get it unsafe. +*/ + osn_var->softirq.arrival_time =time_get (); +set_int_safe_time (osn_var, &osn_var->softirq.delta_start); + osn_var->softirq.count++; + +local_inc (&osn_var->int_counter); +} + +/** +* trace_softirq_exit_callback - Note the end of an SoftIRQ +* +* Computes the duration of the SoftIRQ noise, and trace it. Also discounts the +* interference from other sources of noise could be currently being accounted. +*/ +void trace_softirq_exit_callback (void *data,unsigned int vec_nr) +{ +struct osnoise_variables *osn_var =this_cpu_osn_var (); +int duration; + +if (!osn_var->sampling) +return ; + + duration =get_int_safe_duration (osn_var, &osn_var->softirq.delta_start); +trace_softirq_noise (vec_nr, osn_var->softirq.arrival_time, duration); +cond_move_thread_delta_start (osn_var, duration); + osn_var->softirq.arrival_time =0 ; +} + +/** +* hook_softirq_events - Hook SoftIRQ handling events +* +* This function hooks the SoftIRQ related callbacks to the respective trace +* events. +*/ +static int hook_softirq_events (void ) +{ +int ret; + + ret =register_trace_softirq_entry (trace_softirq_entry_callback,NULL ); +if (ret) + goto out_err; + + ret =register_trace_softirq_exit (trace_softirq_exit_callback,NULL ); +if (ret) + goto out_unreg_entry; + +return 0 ; + +out_unreg_entry: +unregister_trace_softirq_entry (trace_softirq_entry_callback,NULL ); +out_err: +return -EINVAL ; +} + +/** +* unhook_softirq_events - Unhook SoftIRQ handling events +* +* This function hooks the SoftIRQ related callbacks to the respective trace +* events. +*/ +static void unhook_softirq_events (void ) +{ +unregister_trace_softirq_entry (trace_softirq_entry_callback,NULL ); +unregister_trace_softirq_exit (trace_softirq_exit_callback,NULL ); +} +#else /* CONFIG_PREEMPT_RT */ +/* +* SoftIRQ are threads on the PREEMPT_RT mode. +*/ +static int hook_softirq_events (void ) +{ +return 0 ; +} +static void unhook_softirq_events (void ) +{ +} +#endif + +/** +* thread_entry - Record the starting of a thread noise window +* +* It saves the context switch time for a noisy thread, and increments +* the interference counters. +*/ +static void +thread_entry (struct osnoise_variables *osn_var,struct task_struct *t) +{ +if (!osn_var->sampling) +return ; +/* +* The arrival time will be used in the report, but not to compute +* the execution time, so it is safe to get it unsafe. +*/ + osn_var->thread.arrival_time =time_get (); + +set_int_safe_time (osn_var, &osn_var->thread.delta_start); + + osn_var->thread.count++; +local_inc (&osn_var->int_counter); +} + +/** +* thread_exit - Report the end of a thread noise window +* +* It computes the total noise from a thread, tracing if needed. +*/ +static void +thread_exit (struct osnoise_variables *osn_var,struct task_struct *t) +{ +int duration; + +if (!osn_var->sampling) +return ; + + duration =get_int_safe_duration (osn_var, &osn_var->thread.delta_start); + +trace_thread_noise (t, osn_var->thread.arrival_time, duration); + + osn_var->thread.arrival_time =0 ; +} + +/** +* trace_sched_switch - sched:sched_switch trace event handler +* +* This function is hooked to the sched:sched_switch trace event, and it is +* used to record the beginning and to report the end of a thread noise window. +*/ +void +trace_sched_switch_callback (void *data,bool preempt,struct task_struct *p, +struct task_struct *n) +{ +struct osnoise_variables *osn_var =this_cpu_osn_var (); + +if (p->pid != osn_var->pid) +thread_exit (osn_var, p); + +if (n->pid != osn_var->pid) +thread_entry (osn_var, n); +} + +/** +* hook_thread_events - Hook the insturmentation for thread noise +* +* Hook the osnoise tracer callbacks to handle the noise from other +* threads on the necessary kernel events. +*/ +int hook_thread_events (void ) +{ +int ret; + + ret =register_trace_sched_switch (trace_sched_switch_callback,NULL ); +if (ret) +return -EINVAL ; + +return 0 ; +} + +/** +* unhook_thread_events - *nhook the insturmentation for thread noise +* +* Unook the osnoise tracer callbacks to handle the noise from other +* threads on the necessary kernel events. +*/ +void unhook_thread_events (void ) +{ +unregister_trace_sched_switch (trace_sched_switch_callback,NULL ); +} + +/** +* save_osn_sample_stats - Save the osnoise_sample statistics +* +* Save the osnoise_sample statistics before the sampling phase. These +* values will be used later to compute the diff betwneen the statistics +* before and after the osnoise sampling. +*/ +void save_osn_sample_stats (struct osnoise_variables *osn_var,struct osnoise_sample *s) +{ + s->nmi_count = osn_var->nmi.count; + s->irq_count = osn_var->irq.count; + s->softirq_count = osn_var->softirq.count; + s->thread_count = osn_var->thread.count; +} + +/** +* diff_osn_sample_stats - Compute the osnoise_sample statistics +* +* After a sample period, compute the difference on the osnoise_sample +* statistics. The struct osnoise_sample *s contains the statistics saved via +* save_osn_sample_stats() before the osnoise sampling. +*/ +void diff_osn_sample_stats (struct osnoise_variables *osn_var,struct osnoise_sample *s) +{ + s->nmi_count = osn_var->nmi.count - s->nmi_count; + s->irq_count = osn_var->irq.count - s->irq_count;
kernel/trace/trace_osnoise.c line 985
Quoted 10 lines
kernel/trace/trace_osnoise.c new file +10
-0+ s->softirq_count = osn_var->softirq.count - s->softirq_count; + s->thread_count = osn_var->thread.count - s->thread_count; +} + +/** +* osnoise_stop_tracing - Stop tracing and the tracer. +*/ +static void osnoise_stop_tracing (void ) +{ +tracing_off ();
This can run in an instance. The "tracing_off()" affects only the top level tracing buffer, not the instance that this may be running in. You want tracer_tracing_off(tr).
Quoted 28 lines
kernel/trace/trace_osnoise.c new file +28
-0+} + +/** +* run_osnoise - Sample the time and look for osnoise +* +* Used to capture the time, looking for potential osnoise latency repeatedly. +* Different from hwlat_detector, it is called with preemption and interrupts +* enabled. This allows irqs, softirqs and threads to run, interfering on the +* osnoise sampling thread, as they would do with a regular thread. +*/ +static int run_osnoise (void ) +{ +struct osnoise_variables *osn_var =this_cpu_osn_var (); +u64 noise =0 , sum_noise =0 , max_noise =0 ; +struct trace_array *tr = osnoise_trace; +u64 start, sample, last_sample; +u64 last_int_count, int_count; +s64 total, last_total =0 ; +struct osnoise_sample s; +unsigned int threshold; +int hw_count =0 ; +u64 runtime, stop_in; +int ret =-1 ; + +/* +* Considers the current thread as the workload. +*/ + osn_var->pid = current->pid;
kernel/trace/trace_osnoise.c line 1023
Quoted 10 lines
kernel/trace/trace_osnoise.c new file +10
-0+ +/* +* Save the current stats for the diff +*/ +save_osn_sample_stats (osn_var, &s); + +/* +* threshold should be at least 1 us. +*/ + threshold = tracing_thresh ? tracing_thresh :1000 ;
BTW, you can write the above as:
threshold = tracing_thresh ? : 1000;
too ;-)
Quoted 140 lines
kernel/trace/trace_osnoise.c new file +140
-0+ +/* +* Make sure NMIs see sampling first +*/ + osn_var->sampling = true; +barrier (); + +/* +* Transform the *_us config to nanoseconds to avoid the +* division on the main loop. +*/ + runtime = osnoise_data.sample_runtime *NSEC_PER_USEC ; + stop_in = osnoise_data.stop_tracing_in *NSEC_PER_USEC ; + +/* +* Start timestemp +*/ + start =time_get (); + +/* +* "previous" loop +*/ + last_int_count =set_int_safe_time (osn_var, &last_sample); + +do { +/* +* Get sample! +*/ + int_count =set_int_safe_time (osn_var, &sample); + + noise =time_sub (sample, last_sample); + +/* +* This shouldn't happen. +*/ +if (noise <0 ) { +pr_err (BANNER "time running backwards\n" ); + goto out; + } + +/* +* Sample runtime. +*/ + total =time_sub (sample, start); + +/* +* Check for possible overflows. +*/ +if (total < last_total) { +pr_err ("Time total overflowed\n" ); +break ; + } + + last_total = total; + +if (noise >= threshold) { +int interference = int_count - last_int_count; + +if (noise > max_noise) + max_noise = noise; + +if (!interference) + hw_count++; + + sum_noise += noise; + +trace_sample_threshold (last_sample, noise, interference); + +if (osnoise_data.stop_tracing_in) +if (noise > stop_in) +osnoise_stop_tracing (); + } + +/* +* For the non-preemptive kernel config: let threads runs, if +* they so wish. +*/ +cond_resched (); + + last_sample = sample; + last_int_count = int_count; + + }while (total < runtime && !kthread_should_stop ()); + +/* +* Finish the above in the view for interrupts. +*/ +barrier (); + + osn_var->sampling = false; + +/* +* Make sure sampling data is no longer updated. +*/ +barrier (); + +/* +* Save noise info. +*/ + s.noise =time_to_us (sum_noise); + s.runtime =time_to_us (total); + s.max_sample =time_to_us (max_noise); + s.hw_count = hw_count; + +/* Save interference stats info */ +diff_osn_sample_stats (osn_var, &s); + +trace_osnoise_sample (&s); + +/* Keep a running maximum ever recorded osnoise "latency" */ +if (max_noise > tr->max_latency) { + tr->max_latency = max_noise; +latency_fsnotify (tr); + } + +if (osnoise_data.stop_tracing_out) +if (s.noise > osnoise_data.stop_tracing_out) +osnoise_stop_tracing (); + +return 0 ; +out: +return ret; +} + +static struct cpumask osnoise_cpumask; +static struct cpumask save_cpumask; + +/* +* osnoise_main - The osnoise detection kernel thread +* +* Calls run_osnoise() function to measure the osnoise for the configured runtime, +* every period. +*/ +static int osnoise_main (void *data) +{ +s64 interval; + +while (!kthread_should_stop ()) { + +run_osnoise ();
kernel/trace/trace_osnoise.c line 1173
Quoted 10 lines
kernel/trace/trace_osnoise.c new file +10
-0+ +mutex_lock (&interface_lock); + interval = osnoise_data.sample_period - osnoise_data.sample_runtime; +mutex_unlock (&interface_lock); + +do_div (interval,USEC_PER_MSEC ); + +/* +* differently from hwlat_detector, the osnoise tracer can run +* without a pause because preemption is on.
Can it? With !CONFIG_PREEMPT, this will never sleep, right? I believe there's watchdogs that will trigger if a kernel thread never schedules out. I might be wrong, will have to check on this.
Quoted 46 lines
kernel/trace/trace_osnoise.c new file +46
-0+*/ +if (interval <1 ) +continue ; + +if (msleep_interruptible (interval)) +break ; + } + +return 0 ; +} + +/** +* stop_per_cpu_kthread - stop per-cpu threads +* +* Stop the osnoise sampling htread. Use this on unload and at system +* shutdown. +*/ +static void stop_per_cpu_kthreads (void ) +{ +struct task_struct *kthread; +int cpu; + +for_each_online_cpu (cpu) { + kthread =per_cpu (per_cpu_osnoise_var, cpu).kthread; +if (kthread) +kthread_stop (kthread); +per_cpu (per_cpu_osnoise_var, cpu).kthread =NULL ; + } +} + +/** +* start_per_cpu_kthread - Kick off per-cpu osnoise sampling kthreads +* +* This starts the kernel thread that will look for osnoise on many +* cpus. +*/ +static int start_per_cpu_kthreads (struct trace_array *tr) +{ +struct cpumask *current_mask = &save_cpumask; +struct task_struct *kthread; +char comm[24 ]; +int cpu; + +get_online_cpus (); +/* +* Run only on CPUs in which trace and osnoise are allowed to run.
kernel/trace/trace_osnoise.c line 1229
Quoted 10 lines
kernel/trace/trace_osnoise.c new file +10
-0+*/ +cpumask_and (current_mask, tr->tracing_cpumask, &osnoise_cpumask); +/* +* And the CPU is online. +*/ +cpumask_and (current_mask, cpu_online_mask, current_mask); +put_online_cpus (); + +for_each_online_cpu (cpu) +per_cpu (per_cpu_osnoise_var, cpu).kthread =NULL ;
I think we want for_each_possible_cpu(), especially since you don't have anything protecting the online cpus here since you did put_online_cpus. But still, we probably want them all NULL anyway.
Should this have a CPU shutdown notifier, to clean things up if this is running while people are playing with CPU hotplug?
Quoted 72 lines
kernel/trace/trace_osnoise.c new file +72
-0+ +for_each_cpu (cpu, current_mask) { +snprintf (comm,24 ,"osnoise/%d" , cpu); + + kthread =kthread_create_on_cpu (osnoise_main,NULL , cpu, comm); + +if (IS_ERR (kthread)) { +pr_err (BANNER "could not start sampling thread\n" ); +stop_per_cpu_kthreads (); +return -ENOMEM ; + } + +per_cpu (per_cpu_osnoise_var, cpu).kthread = kthread; +wake_up_process (kthread); + } + +return 0 ; +} + +/* +* osnoise_cpus_read - Read function for reading the "cpus" file +* @filp: The active open file structure +* @ubuf: The userspace provided buffer to read value into +* @cnt: The maximum number of bytes to read +* @ppos: The current "file" position +* +* Prints the "cpus" output into the user-provided buffer. +*/ +static ssize_t +osnoise_cpus_read (struct file *filp,char __user *ubuf,size_t count, +loff_t *ppos) +{ +char *mask_str; +int len; + + len =snprintf (NULL ,0 ,"%*pbl\n" , +cpumask_pr_args (&osnoise_cpumask)) +1 ; + mask_str =kmalloc (len,GFP_KERNEL ); +if (!mask_str) +return -ENOMEM ; + + len =snprintf (mask_str, len,"%*pbl\n" , +cpumask_pr_args (&osnoise_cpumask)); +if (len >= count) { + count = -EINVAL ; + goto out_err; + } + count =simple_read_from_buffer (ubuf, count, ppos, mask_str, len); + +out_err: +kfree (mask_str); + +return count; +} + +/** +* osnoise_cpus_write - Write function for "cpus" entry +* @filp: The active open file structure +* @ubuf: The user buffer that contains the value to write +* @cnt: The maximum number of bytes to write to "file" +* @ppos: The current position in @file +* +* This function provides a write implementation for the "cpus" +* interface to the osnoise trace. By default, it lists all CPUs, +* in this way, allowing osnoise threads to run on any online CPU +* of the system. It serves to restrict the execution of osnoise to the +* set of CPUs writing via this interface. Note that osnoise also +* respects the "tracing_cpumask." Hence, osnoise threads will run only +* on the set of CPUs allowed here AND on "tracing_cpumask." Why not +* have just "tracing_cpumask?" Because the user might be interested +* in tracing what is running on other CPUs. For instance, one might +* run osnoise in one HT CPU while observing what is running on the
kernel/trace/trace_osnoise.c line 1311
Quoted 10 lines
kernel/trace/trace_osnoise.c new file +10
-0+* sibling HT CPU. +*/ +static ssize_t +osnoise_cpus_write (struct file *filp,const char __user *ubuf,size_t count, +loff_t *ppos) +{ +cpumask_var_t osnoise_cpumask_new; +char buf[256 ]; +int err; +
Since this does not affect a running osnoise tracer, we should either have it return BUSY if it is running, or have it update the threads during the run.
-- Steve
Quoted 349 lines
kernel/trace/trace_osnoise.c new file +252
-0+if (count >=256 ) +return -EINVAL ; + +if (copy_from_user (buf, ubuf, count)) +return -EFAULT ; + +if (!zalloc_cpumask_var (&osnoise_cpumask_new,GFP_KERNEL )) +return -ENOMEM ; + + err =cpulist_parse (buf, osnoise_cpumask_new); +if (err) + goto err_free; + +cpumask_copy (&osnoise_cpumask, osnoise_cpumask_new); + +free_cpumask_var (osnoise_cpumask_new); +return count; + +err_free: +free_cpumask_var (osnoise_cpumask_new); + +return err; +} + +/* +* osnoise/runtime_us: cannot be greater than the period. +*/ +static struct trace_ull_config osnoise_runtime = { + .lock = &interface_lock, + .val = &osnoise_data.sample_runtime, + .max = &osnoise_data.sample_period, + .min =NULL , +}; + +/* +* osnoise/period_us: cannot be smaller than the runtime. +*/ +static struct trace_ull_config osnoise_period = { + .lock = &interface_lock, + .val = &osnoise_data.sample_period, + .max =NULL , + .min = &osnoise_data.sample_runtime, +}; + +/* +* osnoise/stop_tracing_in_us: no limit. +*/ +static struct trace_ull_config osnoise_stop_single = { + .lock = &interface_lock, + .val = &osnoise_data.stop_tracing_in, + .max =NULL , + .min =NULL , +}; + +/* +* osnoise/stop_tracing_out_us: no limit. +*/ +static struct trace_ull_config osnoise_stop_total = { + .lock = &interface_lock, + .val = &osnoise_data.stop_tracing_out, + .max =NULL , + .min =NULL , +}; + +static const struct file_operations cpus_fops = { + .open = tracing_open_generic, + .read = osnoise_cpus_read, + .write = osnoise_cpus_write, + .llseek = generic_file_llseek, +}; + +/** +* init_tracefs - A function to initialize the tracefs interface files +* +* This function creates entries in tracefs for "osnoise". It creates the +* "osnoise" directory in the tracing directory, and within that +* directory is the count, runtime and period files to change and view +* those values. +*/ +static int init_tracefs (void ) +{ +struct dentry *top_dir; +struct dentry *tmp; +int ret; + + ret =tracing_init_dentry (); +if (ret) +return -ENOMEM ; + + top_dir =tracefs_create_dir ("osnoise" ,NULL ); +if (!top_dir) +return -ENOMEM ; + + tmp =tracefs_create_file ("period_us" ,0640 , top_dir, + &osnoise_period, &trace_ull_config_fops); +if (!tmp) + goto err; + + tmp =tracefs_create_file ("runtime_us" ,0644 , top_dir, + &osnoise_runtime, &trace_ull_config_fops); +if (!tmp) + goto err; + + tmp =tracefs_create_file ("stop_tracing_in_us" ,0640 , top_dir, + &osnoise_stop_single, &trace_ull_config_fops); +if (!tmp) + goto err; + + tmp =tracefs_create_file ("stop_tracing_out_us" ,0640 , top_dir, + &osnoise_stop_total, &trace_ull_config_fops); +if (!tmp) + goto err; + + tmp =trace_create_file ("cpus" ,0644 , top_dir,NULL , &cpus_fops); +if (!tmp) + goto err; + +return 0 ; + +err: +tracefs_remove (top_dir); +return -ENOMEM ; +} + +static int osnoise_hook_events (void ) +{ +int retval; + +/* +* Trace is already hooked, we are re-enabling from +* a stop_tracing_*. +*/ +if (trace_osnoise_callback_enabled) +return 0 ; + + retval =hook_irq_events (); +if (retval) +return -EINVAL ; + + retval =hook_softirq_events (); +if (retval) + goto out_unhook_irq; + + retval =hook_thread_events (); +/* +* All fine! +*/ +if (!retval) +return 0 ; + +unhook_softirq_events (); +out_unhook_irq: +unhook_irq_events (); +return -EINVAL ; +} + +static void osnoise_tracer_start (struct trace_array *tr) +{ +int retval; + +if (osnoise_busy) +return ; + +osn_var_reset_all (); + + retval =osnoise_hook_events (); +if (retval) + goto out_err; +/* +* Make sure NMIs see reseted values. +*/ +barrier (); + trace_osnoise_callback_enabled = true; + + retval =start_per_cpu_kthreads (tr); +/* +* all fine! +*/ +if (!retval) +return ; + +out_err: +unhook_irq_events (); +pr_err (BANNER "Error starting osnoise tracer\n" ); +} + +static void osnoise_tracer_stop (struct trace_array *tr) +{ +if (!osnoise_busy) +return ; + + trace_osnoise_callback_enabled = false; +barrier (); + +stop_per_cpu_kthreads (); + +unhook_irq_events (); +unhook_softirq_events (); +unhook_thread_events (); + + osnoise_busy = false; +} + +static int osnoise_tracer_init (struct trace_array *tr) +{ +/* Only allow one instance to enable this */ +if (osnoise_busy) +return -EBUSY ; + + osnoise_trace = tr; + + tr->max_latency =0 ; + +osnoise_tracer_start (tr); + + osnoise_busy = true; + +return 0 ; +} + +static void osnoise_tracer_reset (struct trace_array *tr) +{ +osnoise_tracer_stop (tr); +} + +static struct tracer osnoise_tracer__read_mostly = { + .name ="osnoise" , + .init = osnoise_tracer_init, + .reset = osnoise_tracer_reset, + .start = osnoise_tracer_start, + .stop = osnoise_tracer_stop, + .print_header = print_osnoise_headers, + .allow_instances = true, +}; + +__init static int init_osnoise_tracer (void ) +{ +int ret; + +mutex_init (&interface_lock); + +cpumask_copy (&osnoise_cpumask, cpu_all_mask); + + ret =register_tracer (&osnoise_tracer); +if (ret) +return ret; + +init_tracefs (); + +return 0 ; +} +late_initcall (init_osnoise_tracer);kernel/trace/trace_output.c +71
-1@@ -1202,7 +1202,6 @@ trace_hwlat_print(struct trace_iterator *iter, int flags,return trace_handle_return (s); } -static enum print_line_t trace_hwlat_raw (struct trace_iterator *iter,int flags,struct trace_event *event)@@ -1232,6 +1231,76 @@ static struct trace_event trace_hwlat_event = { .funcs = &trace_hwlat_funcs, }; +/* TRACE_OSNOISE */ +static enum print_line_t +trace_osnoise_print (struct trace_iterator *iter,int flags, +struct trace_event *event) +{ +struct trace_entry *entry = iter->ent; +struct trace_seq *s = &iter->seq; +struct osnoise_entry *field; +u64 ratio, ratio_dec; +u64 net_runtime; + +trace_assign_type (field, entry); + +/* +* compute the available % of cpu time. +*/ + net_runtime = field->runtime - field->noise; + ratio = net_runtime *10000000 ; +do_div (ratio, field->runtime); + ratio_dec =do_div (ratio,100000 ); + +trace_seq_printf (s,"%llu %10llu %3llu.%05llu %7llu" , + field->runtime, + field->noise, + ratio, ratio_dec, + field->max_sample); + +trace_seq_printf (s," %6u" , field->hw_count); +trace_seq_printf (s," %6u" , field->nmi_count); +trace_seq_printf (s," %6u" , field->irq_count); +trace_seq_printf (s," %6u" , field->softirq_count); +trace_seq_printf (s," %6u" , field->thread_count); + +trace_seq_putc (s,'\n' ); + +return trace_handle_return (s); +} + +static enum print_line_t +trace_osnoise_raw (struct trace_iterator *iter,int flags, +struct trace_event *event) +{ +struct osnoise_entry *field; +struct trace_seq *s = &iter->seq; + +trace_assign_type (field, iter->ent); + +trace_seq_printf (s,"%lld %llu %llu %u %u %u %u %u\n" , + field->runtime, + field->noise, + field->max_sample, + field->hw_count, + field->nmi_count, + field->irq_count, + field->softirq_count, + field->thread_count); + +return trace_handle_return (s); +} + +static struct trace_event_functions trace_osnoise_funcs = { + .trace = trace_osnoise_print, + .raw = trace_osnoise_raw, +}; + +static struct trace_event trace_osnoise_event = { + .type =TRACE_OSNOISE , + .funcs = &trace_osnoise_funcs, +}; +/* TRACE_BPUTS */ static enum print_line_t trace_bputs_print(struct trace_iterator *iter, int flags,@@ -1442,6 +1511,7 @@ static struct trace_event *events[] __initdata = { &trace_bprint_event, &trace_print_event, &trace_hwlat_event, + &trace_osnoise_event, &trace_raw_data_event, &trace_func_repeats_event,NULL
Re: [PATCH V3 8/9] tracing: Add osnoise tracer
Quoted 17 lines · Steven Rostedt
Quoted 4 lines · On Fri, 14 May 2021 22:51:17 +0200 Daniel Bristot de Oliveira…
Tracer options
The tracer has a set of options inside the osnoise directory, they are:
Quoted 9 lines
- osnoise/cpus: CPUs at which a osnoise thread will execute.
- osnoise/period_us: the period of the osnoise thread.
- osnoise/runtime_us: how long an osnoise thread will look for noise.
- osnoise/stop_tracing_in_us: stop the system tracing if a single noise higher than the configured value happens. Writing 0 disables this option.
- osnoise/stop_tracing_out_us: stop the system tracing if total noise higher than the configured value happens. Writing 0 disables this option.
Quoted 3 lines
The "in" vs "out" is confusing. Perhaps we should call it:
stop_tracing_single_usandstop_tracing_total_us?
I am using these more "generic terms" because they are also used by the timerlat tracer.
In the timerlat tracer, the "in" file is used to stop the tracer for a given IRQ latency (so, the "inside" operation), while the "out" is used to stop the tracer in the thread latency (hence the outside operation).
The total sounds good for the "out"! But the single does not work fine for the IRQ... how about: stop_tracing_partial_us ?
It is hard to find a good shared name :-/
Quoted 132 lines
Quoted 117 lines
-
tracing_threshold: the minimum delta between twotime()reads to be considered as noise, in us. When set to 0, the minimum valid value will be used, which is currently 1 us.Additional Tracing
In addition to the tracer, a set of tracepoints were added to facilitate the identification of the osnoise source.
- osnoise:sample_threshold: printed anytime a noise is higher than the configurable
tolerance_ns.
- osnoise:nmi_noise: noise from NMI, including the duration.
- osnoise:irq_noise: noise from an IRQ, including the duration.
- osnoise:softirq_noise: noise from a SoftIRQ, including the duration.
- osnoise:thread_noise: noise from a thread, including the duration.Note that all the values are *net values*. For example, if while osnoise is running, another thread preempts the osnoise thread, it will start a
thread_noiseduration at the start. Then, an IRQ takes place, preempting thethread_noise, starting airq_noise. When the IRQ ends its execution, it will compute its duration, and this duration will be subtracted from thethread_noise, in such a way as to avoid the double accounting of the IRQ execution. This logic is valid for all sources of noise.Here is one example of the usage of these tracepoints::
osnoise/8-961 [008] d.h. 5789.857532: irq_noise: local_timer:236 start 5789.857529929 duration 1845 ns osnoise/8-961 [008] dNh. 5789.858408: irq_noise: local_timer:236 start 5789.858404871 duration 2848 ns migration/8-54 [008] d... 5789.858413: thread_noise: migration/8:54 start 5789.858409300 duration 3068 ns osnoise/8-961 [008] .... 5789.858413: sample_threshold: start 5789.858404555 duration 8723 ns interferences 2In this example, a noise sample of 8 microseconds was reported in the last line, pointing to two interferences. Looking backward in the trace, the two previous entries were about the migration thread running after a timer IRQ execution. The first event is not part of the noise because it took place one millisecond before.
It is worth noticing that the sum of the duration reported in the tracepoints is smaller than eight us reported in the
sample_threshold. The reason roots in the overhead of the entry and exit code that happens before and after any interference execution. This justifies the dual
approach: measuring thread and tracing.kernel/trace/trace_osnoise.c new file +67
-0@@ -0,0 +1,1563 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* OS Noise Tracer: computes the OS Noise suffered by a running thread. +* +* Based on "hwlat_detector" tracer by: +* Copyright (C) 2008-2009 Jon Masters, Red Hat, Inc. <[email protected]> +* Copyright (C) 2013-2016 Steven Rostedt, Red Hat, Inc. <[email protected]> +* With feedback from Clark Williams <[email protected]> +* +* And also based on the rtsl tracer presented on: +* DE OLIVEIRA, Daniel Bristot, et al. Demystifying the real-time linux +* scheduling latency. In: 32nd Euromicro Conference on Real-Time Systems +* (ECRTS 2020). Schloss Dagstuhl-Leibniz-Zentrum fur Informatik, 2020. +* +* Copyright (C) 2021 Daniel Bristot de Oliveira, Red Hat, Inc. <[email protected]> +*/ + +#include <linux/kthread.h> +#include <linux/tracefs.h> +#include <linux/uaccess.h> +#include <linux/cpumask.h> +#include <linux/delay.h> +#include <linux/sched/clock.h> +#include <linux/sched.h> +#include "trace.h" + +#ifdef CONFIG_X86_LOCAL_APIC +#include <asm/trace/irq_vectors.h> +#undef TRACE_INCLUDE_PATH +#undef TRACE_INCLUDE_FILE +#endif /* CONFIG_X86_LOCAL_APIC */ + +#include <trace/events/irq.h> +#include <trace/events/sched.h> + +#define CREATE_TRACE_POINTS +#include <trace/events/osnoise.h> + +static struct trace_array *osnoise_trace; + +/* +* Default values. +*/ +#define BANNER "osnoise: " +#define DEFAULT_SAMPLE_PERIOD 1000000/* 1s */ +#define DEFAULT_SAMPLE_RUNTIME 1000000/* 1s */ + +/* +* NMI runtime info. +*/ +struct nmi { +u64 count; +u64 delta_start; +}; + +/* +* IRQ runtime info. +*/ +struct irq { +u64 count; +u64 arrival_time; +u64 delta_start; +}; + +/* +* SofIRQ runtime info. +*/ kernel/trace/trace_osnoise.c line 77
Quoted 10 lines
kernel/trace/trace_osnoise.c new file +10
-0+struct softirq { +u64 count; +u64 arrival_time; +u64 delta_start; +}; + +/* +* Thread runtime info. +*/ +struct thread {These are rather generic struct names that could possibly be a conflict to something in the future. I would suggest adding "
osn_" or something in front of them:
Quoted 5 lines
struct
osn_nmi
structosn_irq
structosn_threador something like that.
I will use the "osn_" prefix.
Quoted 34 lines
Quoted 10 lines
kernel/trace/trace_osnoise.c new file +9
-0+u64 count; +u64 arrival_time; +u64 delta_start; +}; + +/* +* Runtime information: this structure saves the runtime information used by +* one sampling thread. +*/ kernel/trace/trace_osnoise.c line 96
Quoted 10 lines
kernel/trace/trace_osnoise.c new file +10
-0+struct osnoise_variables { +struct task_struct *kthread; +bool sampling; +pid_t pid; +struct nmi nmi; +struct irq irq; +struct softirq softirq; +struct thread thread; +local_t int_counter; +};Nit, but it looks better to add tabs to the fields:
struct osnoise_variables { sturct task_struct *kthread; bool sampling; pid_t pid; struct nmi nmi; struct irq irq; struct softirq softirq; struct thread thread; local_t int_counter; };
Quoted 1 line
See, it's much easier to see the fields of the structure this way.
yeah, I will change this too.
Quoted 187 lines
Quoted 15 lines
kernel/trace/trace_osnoise.c new file +14
-0+ +/* +* Per-cpu runtime information. +*/ +DEFINE_PER_CPU(struct osnoise_variables, per_cpu_osnoise_var); + +/** +* this_cpu_osn_var - Return the per-cpu osnoise_variables on its relative CPU +*/ +static inline struct osnoise_variables *this_cpu_osn_var (void ) +{ +return this_cpu_ptr (&per_cpu_osnoise_var); +} +kernel/trace/trace_osnoise.c line 120
Quoted 10 lines
kernel/trace/trace_osnoise.c new file +10
-0+/** +* osn_var_reset - Reset the values of the given osnoise_variables +*/ +static inline void osn_var_reset (struct osnoise_variables *osn_var) +{ +/* +* So far, all the values are initialized as 0, so +* zeroing the structure is perfect. +*/ +memset (osn_var,0 ,sizeof (struct osnoise_variables ));I'm one of those that prefer:
memset(osn_var, 0, sizeof(*osn_var))Just in case something changes, you don't need to modify the memset.
Quoted 154 lines
kernel/trace/trace_osnoise.c new file +154
-0+} + +/** +* osn_var_reset_all - Reset the value of all per-cpu osnoise_variables +*/ +static inline void osn_var_reset_all (void ) +{ +struct osnoise_variables *osn_var; +int cpu; + +for_each_cpu (cpu, cpu_online_mask) { + osn_var =per_cpu_ptr (&per_cpu_osnoise_var, cpu); +osn_var_reset (osn_var); + } +} + +/* +* Tells NMIs to call back to the osnoise tracer to record timestamps. +*/ +bool trace_osnoise_callback_enabled; + +/* +* osnoise sample structure definition. Used to store the statistics of a +* sample run. +*/ +struct osnoise_sample { +u64 runtime;/* runtime */ +u64 noise;/* noise */ +u64 max_sample;/* max single noise sample */ +int hw_count;/* # HW (incl. hypervisor) interference */ +int nmi_count;/* # NMIs during this sample */ +int irq_count;/* # IRQs during this sample */ +int softirq_count;/* # SoftIRQs during this sample */ +int thread_count;/* # Threads during this sample */ +}; + +/* +* Protect the interface. +*/ +struct mutex interface_lock; + +/* +* Tracer data. +*/ +static struct osnoise_data { +u64 sample_period;/* total sampling period */ +u64 sample_runtime;/* active sampling portion of period */ +u64 stop_tracing_in;/* stop trace in the inside operation (loop) */ +u64 stop_tracing_out;/* stop trace in the outside operation (report) */ +} osnoise_data = { + .sample_period =DEFAULT_SAMPLE_PERIOD , + .sample_runtime =DEFAULT_SAMPLE_RUNTIME , + .stop_tracing_in =0 , + .stop_tracing_out =0 , +}; + +/* +* Boolean variable used to inform that the tracer is currently sampling. +*/ +static bool osnoise_busy; + +/* +* Print the osnoise header info. +*/ +static void print_osnoise_headers (struct seq_file *s) +{ +seq_puts (s,"# _-----=> irqs-off\n" ); +seq_puts (s,"# / _----=> need-resched\n" ); +seq_puts (s,"# | / _---=> hardirq/softirq\n" ); +seq_puts (s,"# || / _--=> preempt-depth " ); +seq_puts (s," MAX\n" ); + +seq_puts (s,"# || / " ); +seq_puts (s," SINGLE Interference counters:\n" ); + +seq_puts (s,"# |||| RUNTIME " ); +seq_puts (s," NOISE %% OF CPU NOISE +-----------------------------+\n" ); + +seq_puts (s,"# TASK-PID CPU# |||| TIMESTAMP IN US " ); +seq_puts (s," IN US AVAILABLE IN US HW NMI IRQ SIRQ THREAD\n" ); + +seq_puts (s,"# | | | |||| | | " ); +seq_puts (s," | | | | | | | |\n" ); +} + +/* +* Record an osnoise_sample into the tracer buffer. +*/ +static void trace_osnoise_sample (struct osnoise_sample *sample) +{ +struct trace_array *tr = osnoise_trace; +struct trace_buffer *buffer = tr->array_buffer.buffer; +struct trace_event_call *call = &event_osnoise; +struct ring_buffer_event *event; +struct osnoise_entry *entry; + + event =trace_buffer_lock_reserve (buffer,TRACE_OSNOISE ,sizeof (*entry), +tracing_gen_ctx ()); +if (!event) +return ; + entry =ring_buffer_event_data (event); + entry->runtime = sample->runtime; + entry->noise = sample->noise; + entry->max_sample = sample->max_sample; + entry->hw_count = sample->hw_count; + entry->nmi_count = sample->nmi_count; + entry->irq_count = sample->irq_count; + entry->softirq_count = sample->softirq_count; + entry->thread_count = sample->thread_count; + +if (!call_filter_check_discard (call, entry, buffer, event)) +trace_buffer_unlock_commit_nostack (buffer, event); +} + +/** +* Macros to encapsulate the time capturing infrastructure. +*/ +#define time_get () trace_clock_local() +#define time_to_us (x) div_u64(x, 1000) +#define time_sub (a, b) ((a) - (b)) + +/** +* cond_move_irq_delta_start - Forward the delta_start of a running IRQ +* +* If an IRQ is preempted by an NMI, its delta_start is pushed forward +* to discount the NMI interference. +* +* See get_int_safe_duration(). +*/ +static inline void +cond_move_irq_delta_start (struct osnoise_variables *osn_var,u64 duration) +{ +if (osn_var->irq.delta_start) + osn_var->irq.delta_start += duration; +} + +#ifndef CONFIG_PREEMPT_RT +/** +* cond_move_softirq_delta_start - Forward the delta_start of a running SoftIRQ +* +* If a SoftIRQ is preempted by an IRQ or NMI, its delta_start is pushed +* forward to discount the interference. +* +* See get_int_safe_duration(). +*/ +static inline void +cond_move_softirq_delta_start (struct osnoise_variables *osn_var,u64 duration) +{ +if (osn_var->softirq.delta_start) + osn_var->softirq.delta_start += duration; +} +#else /* CONFIG_PREEMPT_RT */ +#define cond_move_softirq_delta_start (osn_var, duration) do {} while (0) +#endif
Quoted 8 lines
kernel/trace/trace_osnoise.c line 276
Quoted 2 lines
kernel/trace/trace_osnoise.c new file +2
-0+ +/** Don't use the "/**" notation if you are not following kernel doc (which means you need to also document each parameter and return value. The '/**' is usually reserved for non static functions that are an API for other parts of the kernel. Use just '/*' for these (unless you want to add full kernel doc notation).
ok!
Quoted 64 lines
Quoted 64 lines
kernel/trace/trace_osnoise.c new file +64
-0+* cond_move_thread_delta_start - Forward the delta_start of a running thread +* +* If a noisy thread is preempted by an Softirq, IRQ or NMI, its delta_start +* is pushed forward to discount the interference. +* +* See get_int_safe_duration(). +*/ +static inline void +cond_move_thread_delta_start (struct osnoise_variables *osn_var,u64 duration) +{ +if (osn_var->thread.delta_start) + osn_var->thread.delta_start += duration; +} + +/** +* get_int_safe_duration - Get the duration of a window +* +* The irq, softirq and thread varaibles need to have its duration without +* the interference from higher priority interrupts. Instead of keeping a +* variable to discount the interrupt interference from these variables, the +* starting time of these variables are pushed forward with the interrupt's +* duration. In this way, a single variable is used to: +* +* - Know if a given window is being measured. +* - Account its duration. +* - Discount the interference. +* +* To avoid getting inconsistent values, e.g.,: +* +* now = time_get() +* ---> interrupt! +* delta_start -= int duration; +* <--- +* duration = now - delta_start; +* +* result: negative duration if the variable duration before the +* interrupt was smaller than the interrupt execution. +* +* A counter of interrupts is used. If the counter increased, try +* to capture an interference safe duration. +*/ +static inline s64 +get_int_safe_duration (struct osnoise_variables *osn_var,u64 *delta_start) +{ +u64 int_counter, now; +s64 duration; + +do { + int_counter =local_read (&osn_var->int_counter); +/* synchronize with interrupts */ +barrier (); + + now =time_get (); + duration = (now - *delta_start); + +/* synchronize with interrupts */ +barrier (); + }while (int_counter !=local_read (&osn_var->int_counter)); + +/* +* This is an evidence of race conditions that cause +* a value to be "discounted" too much. +*/ +if (duration <0 )
Quoted 8 lines
kernel/trace/trace_osnoise.c line 341
Quoted 1 line
kernel/trace/trace_osnoise.c new file +1
-0+pr_err ("int safe negative!\n" );Probably want to have this happen at most once a run. If something were to break, I don't think we want this to live lock the machine doing tons of prints. We could have a variable stored on the
osnoise_variablesthat states this was printed. Check that variable to see if it wasn't printed during a run (whencurrent_tracerwas set), and print only once if it is.
yeah, also because this could happen in a section that printk does not work fine.
Quoted 23 lines
Quoted 23 lines
kernel/trace/trace_osnoise.c new file +22
-0+ + *delta_start =0 ; + +return duration; +} + +/** +* +* set_int_safe_time - Save the current time on *time, aware of interference +* +* Get the time, taking into consideration a possible interference from +* higher priority interrupts. +* +* See get_int_safe_duration() for an explanation. +*/ +static u64 +set_int_safe_time (struct osnoise_variables *osn_var,u64 *time) +{ +u64 int_counter; + + do { + int_counter = local_read(&osn_var->int_counter);
Quoted 8 lines
kernel/trace/trace_osnoise.c line 367
Quoted 4 lines
kernel/trace/trace_osnoise.c new file +4
-0+/* synchronize with interrupts */ +barrier (); + + *time =time_get ();
time_get()istrace_clock_local()which is used in tracing, and should not be affected by interrupts. Why the loop? Even if using the generic NMI-unsafe version ofsched_clock, it does its own loop.
The loop is there to synchronize the *time and the int_counter that is returned...
Quoted 111 lines
Quoted 111 lines
kernel/trace/trace_osnoise.c new file +111
-0+ +/* synchronize with interrupts */ +barrier (); + }while (int_counter !=local_read (&osn_var->int_counter)); + +return int_counter; +} + +/** +* trace_osnoise_callback - NMI entry/exit callback +* +* This function is called at the entry and exit NMI code. The bool enter +* distinguishes between either case. This function is used to note a NMI +* occurrence, compute the noise caused by the NMI, and to remove the noise +* it is potentially causing on other interference variables. +*/ +void trace_osnoise_callback (bool enter) +{ +struct osnoise_variables *osn_var =this_cpu_osn_var (); +u64 duration; + +if (!osn_var->sampling) +return ; + +/* +* Currently trace_clock_local() calls sched_clock() and the +* generic version is not NMI safe. +*/ +if (!IS_ENABLED (CONFIG_GENERIC_SCHED_CLOCK )) { +if (enter) { + osn_var->nmi.delta_start =time_get (); +local_inc (&osn_var->int_counter); + }else { + duration =time_get () - osn_var->nmi.delta_start; + +trace_nmi_noise (osn_var->nmi.delta_start, duration); + +cond_move_irq_delta_start (osn_var, duration); +cond_move_softirq_delta_start (osn_var, duration); +cond_move_thread_delta_start (osn_var, duration); + } + } + +if (enter) + osn_var->nmi.count++; +} + +/** +* __trace_irq_entry - Note the starting of an IRQ +* +* Save the starting time of an IRQ. As IRQs are non-preemptive to other IRQs, +* it is safe to use a single variable (ons_var->irq) to save the statistics. +* The arrival_time is used to report... the arrival time. The delta_start +* is used to compute the duration at the IRQ exit handler. See +* cond_move_irq_delta_start(). +*/ +static inline void __trace_irq_entry (int id) +{ +struct osnoise_variables *osn_var =this_cpu_osn_var (); + +if (!osn_var->sampling) +return ; +/* +* This value will be used in the report, but not to compute +* the execution time, so it is safe to get it unsafe. +*/ + osn_var->irq.arrival_time =time_get (); +set_int_safe_time (osn_var, &osn_var->irq.delta_start); + osn_var->irq.count++; + +local_inc (&osn_var->int_counter); +} + +/** +* __trace_irq_exit - Note the end of an IRQ, sava data and trace +* +* Computes the duration of the IRQ noise, and trace it. Also discounts the +* interference from other sources of noise could be currently being accounted. +*/ +static inline void __trace_irq_exit (int id,const char *desc) +{ +struct osnoise_variables *osn_var =this_cpu_osn_var (); +int duration; + +if (!osn_var->sampling) +return ; + + duration =get_int_safe_duration (osn_var, &osn_var->irq.delta_start); +trace_irq_noise (id, desc, osn_var->irq.arrival_time, duration); + osn_var->irq.arrival_time =0 ; +cond_move_softirq_delta_start (osn_var, duration); +cond_move_thread_delta_start (osn_var, duration); +} + +/** +* trace_irqentry_callback - Callback to the irq:irq_entry traceevent +* +* Used to note the starting of an IRQ occurece. +*/ +void trace_irqentry_callback (void *data,int irq,struct irqaction *action) +{ +__trace_irq_entry (irq); +} + +/** +* trace_irqexit_callback - Callback to the irq:irq_exit traceevent +* +* Used to note the end of an IRQ occurece. +*/ +void trace_irqexit_callback (void *data,int irq,struct irqaction *action,int ret) +{
Quoted 8 lines
kernel/trace/trace_osnoise.c line 482
Quoted 4 lines
kernel/trace/trace_osnoise.c new file +4
-0+__trace_irq_exit (irq, action->name); +} + +#ifdef CONFIG_X86_LOCAL_APIC I wonder if we should move this into a separate file, making the
__trace_irq_entry()a more name space safe name and have it call that. I have a bit of a distaste for arch specific code in a generic file.
Yeah, where should I place it? somewhere in arch/x86?
Quoted 233 lines
Quoted 231 lines
kernel/trace/trace_osnoise.c new file +230
-0+/** +* trace_intel_irq_entry - record intel specific IRQ entry +*/ +void trace_intel_irq_entry (void *data,int vector) +{ +__trace_irq_entry (vector); +} + +/** +* trace_intel_irq_exit - record intel specific IRQ exit +*/ +void trace_intel_irq_exit (void *data,int vector) +{ +char *vector_desc = (char *) data; + +__trace_irq_exit (vector, vector_desc); +} + +/** +* register_intel_irq_tp - Register intel specific IRQ entry tracepoints +*/ +static int register_intel_irq_tp (void ) +{ +int ret; + + ret =register_trace_local_timer_entry (trace_intel_irq_entry,NULL ); +if (ret) + goto out_err; + + ret =register_trace_local_timer_exit (trace_intel_irq_exit,"local_timer" ); +if (ret) + goto out_timer_entry; + +#ifdef CONFIG_X86_THERMAL_VECTOR + ret =register_trace_thermal_apic_entry (trace_intel_irq_entry,NULL ); +if (ret) + goto out_timer_exit; + + ret =register_trace_thermal_apic_exit (trace_intel_irq_exit,"thermal_apic" ); +if (ret) + goto out_thermal_entry; +#endif /* CONFIG_X86_THERMAL_VECTOR */ + +#ifdef CONFIG_X86_MCE_AMD + ret =register_trace_deferred_error_apic_entry (trace_intel_irq_entry,NULL ); +if (ret) + goto out_thermal_exit; + + ret =register_trace_deferred_error_apic_exit (trace_intel_irq_exit,"deferred_error" ); +if (ret) + goto out_deferred_entry; +#endif + +#ifdef CONFIG_X86_MCE_THRESHOLD + ret =register_trace_threshold_apic_entry (trace_intel_irq_entry,NULL ); +if (ret) + goto out_deferred_exit; + + ret =register_trace_threshold_apic_exit (trace_intel_irq_exit,"threshold_apic" ); +if (ret) + goto out_threshold_entry; +#endif /* CONFIG_X86_MCE_THRESHOLD */ + +#ifdef CONFIG_SMP + ret =register_trace_call_function_single_entry (trace_intel_irq_entry,NULL ); +if (ret) + goto out_threshold_exit; + + ret =register_trace_call_function_single_exit (trace_intel_irq_exit, +"call_function_single" ); +if (ret) + goto out_call_function_single_entry; + + ret =register_trace_call_function_entry (trace_intel_irq_entry,NULL ); +if (ret) + goto out_call_function_single_exit; + + ret =register_trace_call_function_exit (trace_intel_irq_exit,"call_function" ); +if (ret) + goto out_call_function_entry; + + ret =register_trace_reschedule_entry (trace_intel_irq_entry,NULL ); +if (ret) + goto out_call_function_exit; + + ret =register_trace_reschedule_exit (trace_intel_irq_exit,"reschedule" ); +if (ret) + goto out_reschedule_entry; +#endif /* CONFIG_SMP */ + +#ifdef CONFIG_IRQ_WORK + ret =register_trace_irq_work_entry (trace_intel_irq_entry,NULL ); +if (ret) + goto out_reschedule_exit; + + ret =register_trace_irq_work_exit (trace_intel_irq_exit,"irq_work" ); +if (ret) + goto out_irq_work_entry; +#endif + + ret =register_trace_x86_platform_ipi_entry (trace_intel_irq_entry,NULL ); +if (ret) + goto out_irq_work_exit; + + ret =register_trace_x86_platform_ipi_exit (trace_intel_irq_exit,"x86_platform_ipi" ); +if (ret) + goto out_x86_ipi_entry; + + ret =register_trace_error_apic_entry (trace_intel_irq_entry,NULL ); +if (ret) + goto out_x86_ipi_exit; + + ret =register_trace_error_apic_exit (trace_intel_irq_exit,"error_apic" ); +if (ret) + goto out_error_apic_entry; + + ret =register_trace_spurious_apic_entry (trace_intel_irq_entry,NULL ); +if (ret) + goto out_error_apic_exit; + + ret =register_trace_spurious_apic_exit (trace_intel_irq_exit,"spurious_apic" ); +if (ret) + goto out_spurious_apic_entry; + +return 0 ; + +out_spurious_apic_entry: +unregister_trace_spurious_apic_entry (trace_intel_irq_entry,NULL ); +out_error_apic_exit: +unregister_trace_error_apic_exit (trace_intel_irq_exit,"error_apic" ); +out_error_apic_entry: +unregister_trace_error_apic_entry (trace_intel_irq_entry,NULL ); +out_x86_ipi_exit: +unregister_trace_x86_platform_ipi_exit (trace_intel_irq_exit,"x86_platform_ipi" ); +out_x86_ipi_entry: +unregister_trace_x86_platform_ipi_entry (trace_intel_irq_entry,NULL ); +out_irq_work_exit: + +#ifdef CONFIG_IRQ_WORK +unregister_trace_irq_work_exit (trace_intel_irq_exit,"irq_work" ); +out_irq_work_entry: +unregister_trace_irq_work_entry (trace_intel_irq_entry,NULL ); +out_reschedule_exit: +#endif + +#ifdef CONFIG_SMP +unregister_trace_reschedule_exit (trace_intel_irq_exit,"reschedule" ); +out_reschedule_entry: +unregister_trace_reschedule_entry (trace_intel_irq_entry,NULL ); +out_call_function_exit: +unregister_trace_call_function_exit (trace_intel_irq_exit,"call_function" ); +out_call_function_entry: +unregister_trace_call_function_entry (trace_intel_irq_entry,NULL ); +out_call_function_single_exit: +unregister_trace_call_function_single_exit (trace_intel_irq_exit,"call_function_single" ); +out_call_function_single_entry: +unregister_trace_call_function_single_entry (trace_intel_irq_entry,NULL ); +out_threshold_exit: +#endif + +#ifdef CONFIG_X86_MCE_THRESHOLD +unregister_trace_threshold_apic_exit (trace_intel_irq_exit,"threshold_apic" ); +out_threshold_entry: +unregister_trace_threshold_apic_entry (trace_intel_irq_entry,NULL ); +out_deferred_exit: +#endif + +#ifdef CONFIG_X86_MCE_AMD +unregister_trace_deferred_error_apic_exit (trace_intel_irq_exit,"deferred_error" ); +out_deferred_entry: +unregister_trace_deferred_error_apic_entry (trace_intel_irq_entry,NULL ); +out_thermal_exit: +#endif /* CONFIG_X86_MCE_AMD */ + +#ifdef CONFIG_X86_THERMAL_VECTOR +unregister_trace_thermal_apic_exit (trace_intel_irq_exit,"thermal_apic" ); +out_thermal_entry: +unregister_trace_thermal_apic_entry (trace_intel_irq_entry,NULL ); +out_timer_exit: +#endif /* CONFIG_X86_THERMAL_VECTOR */ + +unregister_trace_local_timer_exit (trace_intel_irq_exit,"local_timer" ); +out_timer_entry: +unregister_trace_local_timer_entry (trace_intel_irq_entry,NULL ); +out_err: +return -EINVAL ; +} + +static void unregister_intel_irq_tp (void ) +{ +unregister_trace_spurious_apic_exit (trace_intel_irq_exit,"spurious_apic" ); +unregister_trace_spurious_apic_entry (trace_intel_irq_entry,NULL ); +unregister_trace_error_apic_exit (trace_intel_irq_exit,"error_apic" ); +unregister_trace_error_apic_entry (trace_intel_irq_entry,NULL ); +unregister_trace_x86_platform_ipi_exit (trace_intel_irq_exit,"x86_platform_ipi" ); +unregister_trace_x86_platform_ipi_entry (trace_intel_irq_entry,NULL ); + +#ifdef CONFIG_IRQ_WORK +unregister_trace_irq_work_exit (trace_intel_irq_exit,"irq_work" ); +unregister_trace_irq_work_entry (trace_intel_irq_entry,NULL ); +#endif + +#ifdef CONFIG_SMP +unregister_trace_reschedule_exit (trace_intel_irq_exit,"reschedule" ); +unregister_trace_reschedule_entry (trace_intel_irq_entry,NULL ); +unregister_trace_call_function_exit (trace_intel_irq_exit,"call_function" ); +unregister_trace_call_function_entry (trace_intel_irq_entry,NULL ); +unregister_trace_call_function_single_exit (trace_intel_irq_exit,"call_function_single" ); +unregister_trace_call_function_single_entry (trace_intel_irq_entry,NULL ); +#endif + +#ifdef CONFIG_X86_MCE_THRESHOLD +unregister_trace_threshold_apic_exit (trace_intel_irq_exit,"threshold_apic" ); +unregister_trace_threshold_apic_entry (trace_intel_irq_entry,NULL ); +#endif + +#ifdef CONFIG_X86_MCE_AMD +unregister_trace_deferred_error_apic_exit (trace_intel_irq_exit,"deferred_error" ); +unregister_trace_deferred_error_apic_entry (trace_intel_irq_entry,NULL ); +#endif + +#ifdef CONFIG_X86_THERMAL_VECTOR +unregister_trace_thermal_apic_exit (trace_intel_irq_exit,"thermal_apic" ); +unregister_trace_thermal_apic_entry (trace_intel_irq_entry,NULL ); +#endif /* CONFIG_X86_THERMAL_VECTOR */ + +unregister_trace_local_timer_exit (trace_intel_irq_exit,"local_timer" ); +unregister_trace_local_timer_entry (trace_intel_irq_entry,NULL ); +} +
Quoted 6 lines
kernel/trace/trace_osnoise.c line 716
Quoted 4 lines
kernel/trace/trace_osnoise.c new file +4
-0+#else /* CONFIG_X86_LOCAL_APIC */ +#define register_intel_irq_tp () do {} while (0) +#define unregister_intel_irq_tp () do {} while (0) +#endif /* CONFIG_X86_LOCAL_APIC */ And have this in a local header file.
kernel/trace/trace_osnoise.h?
Ack! Also because these osnoise: tracepoints will be used by yet another tracers, the rtsl... https://github.com/bristot/rtsl/ (I hope :-))
Quoted 46 lines
Quoted 46 lines
kernel/trace/trace_osnoise.c new file +45
-0+ +/** +* hook_irq_events - Hook IRQ handling events +* +* This function hooks the IRQ related callbacks to the respective trace +* events. +*/ +int hook_irq_events (void ) +{ +int ret; + + ret =register_trace_irq_handler_entry (trace_irqentry_callback,NULL ); +if (ret) + goto out_err; + + ret =register_trace_irq_handler_exit (trace_irqexit_callback,NULL ); +if (ret) + goto out_unregister_entry; + + ret =register_intel_irq_tp (); +if (ret) + goto out_irq_exit; + +return 0 ; + +out_irq_exit: +unregister_trace_irq_handler_exit (trace_irqexit_callback,NULL ); +out_unregister_entry: +unregister_trace_irq_handler_entry (trace_irqentry_callback,NULL ); +out_err: +return -EINVAL ; +} + +/** +* unhook_irq_events - Unhook IRQ handling events +* +* This function unhooks the IRQ related callbacks to the respective trace +* events. +*/ +void unhook_irq_events (void ) +{ +unregister_intel_irq_tp (); +unregister_trace_irq_handler_exit (trace_irqexit_callback,NULL ); +unregister_trace_irq_handler_entry (trace_irqentry_callback,NULL ); +}
Quoted 8 lines
kernel/trace/trace_osnoise.c line 765
Quoted 4 lines
kernel/trace/trace_osnoise.c new file +4
-0+ +#ifndef CONFIG_PREEMPT_RT +/** +* trace_softirq_entry_callback - Note the starting of a SoftIRQ Where did you get the case usage of that. I've never seen it written like "SoftIRQ" in the kernel. Just call it softirq as it is referenced everyplace else.
I do not remember when, but I was already asked to use this "SoftIRQ" once.. I anyway, I prefer "softirq" too. I will use it.
Quoted 216 lines
Quoted 216 lines
kernel/trace/trace_osnoise.c new file +216
-0+* +* Save the starting time of a SoftIRQ. As SoftIRQs are non-preemptive to +* other SoftIRQs, it is safe to use a single variable (ons_var->softirq) +* to save the statistics. The arrival_time is used to report... the +* arrival time. The delta_start is used to compute the duration at the +* SoftIRQ exit handler. See cond_move_softirq_delta_start(). +*/ +void trace_softirq_entry_callback (void *data,unsigned int vec_nr) +{ +struct osnoise_variables *osn_var =this_cpu_osn_var (); + +if (!osn_var->sampling) +return ; +/* +* This value will be used in the report, but not to compute +* the execution time, so it is safe to get it unsafe. +*/ + osn_var->softirq.arrival_time =time_get (); +set_int_safe_time (osn_var, &osn_var->softirq.delta_start); + osn_var->softirq.count++; + +local_inc (&osn_var->int_counter); +} + +/** +* trace_softirq_exit_callback - Note the end of an SoftIRQ +* +* Computes the duration of the SoftIRQ noise, and trace it. Also discounts the +* interference from other sources of noise could be currently being accounted. +*/ +void trace_softirq_exit_callback (void *data,unsigned int vec_nr) +{ +struct osnoise_variables *osn_var =this_cpu_osn_var (); +int duration; + +if (!osn_var->sampling) +return ; + + duration =get_int_safe_duration (osn_var, &osn_var->softirq.delta_start); +trace_softirq_noise (vec_nr, osn_var->softirq.arrival_time, duration); +cond_move_thread_delta_start (osn_var, duration); + osn_var->softirq.arrival_time =0 ; +} + +/** +* hook_softirq_events - Hook SoftIRQ handling events +* +* This function hooks the SoftIRQ related callbacks to the respective trace +* events. +*/ +static int hook_softirq_events (void ) +{ +int ret; + + ret =register_trace_softirq_entry (trace_softirq_entry_callback,NULL ); +if (ret) + goto out_err; + + ret =register_trace_softirq_exit (trace_softirq_exit_callback,NULL ); +if (ret) + goto out_unreg_entry; + +return 0 ; + +out_unreg_entry: +unregister_trace_softirq_entry (trace_softirq_entry_callback,NULL ); +out_err: +return -EINVAL ; +} + +/** +* unhook_softirq_events - Unhook SoftIRQ handling events +* +* This function hooks the SoftIRQ related callbacks to the respective trace +* events. +*/ +static void unhook_softirq_events (void ) +{ +unregister_trace_softirq_entry (trace_softirq_entry_callback,NULL ); +unregister_trace_softirq_exit (trace_softirq_exit_callback,NULL ); +} +#else /* CONFIG_PREEMPT_RT */ +/* +* SoftIRQ are threads on the PREEMPT_RT mode. +*/ +static int hook_softirq_events (void ) +{ +return 0 ; +} +static void unhook_softirq_events (void ) +{ +} +#endif + +/** +* thread_entry - Record the starting of a thread noise window +* +* It saves the context switch time for a noisy thread, and increments +* the interference counters. +*/ +static void +thread_entry (struct osnoise_variables *osn_var,struct task_struct *t) +{ +if (!osn_var->sampling) +return ; +/* +* The arrival time will be used in the report, but not to compute +* the execution time, so it is safe to get it unsafe. +*/ + osn_var->thread.arrival_time =time_get (); + +set_int_safe_time (osn_var, &osn_var->thread.delta_start); + + osn_var->thread.count++; +local_inc (&osn_var->int_counter); +} + +/** +* thread_exit - Report the end of a thread noise window +* +* It computes the total noise from a thread, tracing if needed. +*/ +static void +thread_exit (struct osnoise_variables *osn_var,struct task_struct *t) +{ +int duration; + +if (!osn_var->sampling) +return ; + + duration =get_int_safe_duration (osn_var, &osn_var->thread.delta_start); + +trace_thread_noise (t, osn_var->thread.arrival_time, duration); + + osn_var->thread.arrival_time =0 ; +} + +/** +* trace_sched_switch - sched:sched_switch trace event handler +* +* This function is hooked to the sched:sched_switch trace event, and it is +* used to record the beginning and to report the end of a thread noise window. +*/ +void +trace_sched_switch_callback (void *data,bool preempt,struct task_struct *p, +struct task_struct *n) +{ +struct osnoise_variables *osn_var =this_cpu_osn_var (); + +if (p->pid != osn_var->pid) +thread_exit (osn_var, p); + +if (n->pid != osn_var->pid) +thread_entry (osn_var, n); +} + +/** +* hook_thread_events - Hook the insturmentation for thread noise +* +* Hook the osnoise tracer callbacks to handle the noise from other +* threads on the necessary kernel events. +*/ +int hook_thread_events (void ) +{ +int ret; + + ret =register_trace_sched_switch (trace_sched_switch_callback,NULL ); +if (ret) +return -EINVAL ; + +return 0 ; +} + +/** +* unhook_thread_events - *nhook the insturmentation for thread noise +* +* Unook the osnoise tracer callbacks to handle the noise from other +* threads on the necessary kernel events. +*/ +void unhook_thread_events (void ) +{ +unregister_trace_sched_switch (trace_sched_switch_callback,NULL ); +} + +/** +* save_osn_sample_stats - Save the osnoise_sample statistics +* +* Save the osnoise_sample statistics before the sampling phase. These +* values will be used later to compute the diff betwneen the statistics +* before and after the osnoise sampling. +*/ +void save_osn_sample_stats (struct osnoise_variables *osn_var,struct osnoise_sample *s) +{ + s->nmi_count = osn_var->nmi.count; + s->irq_count = osn_var->irq.count; + s->softirq_count = osn_var->softirq.count; + s->thread_count = osn_var->thread.count; +} + +/** +* diff_osn_sample_stats - Compute the osnoise_sample statistics +* +* After a sample period, compute the difference on the osnoise_sample +* statistics. The struct osnoise_sample *s contains the statistics saved via +* save_osn_sample_stats() before the osnoise sampling. +*/ +void diff_osn_sample_stats (struct osnoise_variables *osn_var,struct osnoise_sample *s) +{ + s->nmi_count = osn_var->nmi.count - s->nmi_count; + s->irq_count = osn_var->irq.count - s->irq_count; + s->softirq_count = osn_var->softirq.count - s->softirq_count; + s->thread_count = osn_var->thread.count - s->thread_count; +} + +/** +* osnoise_stop_tracing - Stop tracing and the tracer.
Quoted 8 lines
kernel/trace/trace_osnoise.c line 985
Quoted 4 lines
kernel/trace/trace_osnoise.c new file +4
-0+*/ +static void osnoise_stop_tracing (void ) +{ +tracing_off ();This can run in an instance. The "
tracing_off()" affects only the top level tracing buffer, not the instance that this may be running in. You wanttracer_tracing_off(tr).
ack!
Quoted 193 lines
Quoted 28 lines
kernel/trace/trace_osnoise.c new file +28
-0+} + +/** +* run_osnoise - Sample the time and look for osnoise +* +* Used to capture the time, looking for potential osnoise latency repeatedly. +* Different from hwlat_detector, it is called with preemption and interrupts +* enabled. This allows irqs, softirqs and threads to run, interfering on the +* osnoise sampling thread, as they would do with a regular thread. +*/ +static int run_osnoise (void ) +{ +struct osnoise_variables *osn_var =this_cpu_osn_var (); +u64 noise =0 , sum_noise =0 , max_noise =0 ; +struct trace_array *tr = osnoise_trace; +u64 start, sample, last_sample; +u64 last_int_count, int_count; +s64 total, last_total =0 ; +struct osnoise_sample s; +unsigned int threshold; +int hw_count =0 ; +u64 runtime, stop_in; +int ret =-1 ; + +/* +* Considers the current thread as the workload. +*/ + osn_var->pid = current->pid;kernel/trace/trace_osnoise.c line 1023
Quoted 10 lines
kernel/trace/trace_osnoise.c new file +10
-0+ +/* +* Save the current stats for the diff +*/ +save_osn_sample_stats (osn_var, &s); + +/* +* threshold should be at least 1 us. +*/ + threshold = tracing_thresh ? tracing_thresh :1000 ;BTW, you can write the above as:
threshold = tracing_thresh ? : 1000;too ;-)
Quoted 147 lines
kernel/trace/trace_osnoise.c new file +147
-0+ +/* +* Make sure NMIs see sampling first +*/ + osn_var->sampling = true; +barrier (); + +/* +* Transform the *_us config to nanoseconds to avoid the +* division on the main loop. +*/ + runtime = osnoise_data.sample_runtime *NSEC_PER_USEC ; + stop_in = osnoise_data.stop_tracing_in *NSEC_PER_USEC ; + +/* +* Start timestemp +*/ + start =time_get (); + +/* +* "previous" loop +*/ + last_int_count =set_int_safe_time (osn_var, &last_sample); + +do { +/* +* Get sample! +*/ + int_count =set_int_safe_time (osn_var, &sample); + + noise =time_sub (sample, last_sample); + +/* +* This shouldn't happen. +*/ +if (noise <0 ) { +pr_err (BANNER "time running backwards\n" ); + goto out; + } + +/* +* Sample runtime. +*/ + total =time_sub (sample, start); + +/* +* Check for possible overflows. +*/ +if (total < last_total) { +pr_err ("Time total overflowed\n" ); +break ; + } + + last_total = total; + +if (noise >= threshold) { +int interference = int_count - last_int_count; + +if (noise > max_noise) + max_noise = noise; + +if (!interference) + hw_count++; + + sum_noise += noise; + +trace_sample_threshold (last_sample, noise, interference); + +if (osnoise_data.stop_tracing_in) +if (noise > stop_in) +osnoise_stop_tracing (); + } + +/* +* For the non-preemptive kernel config: let threads runs, if +* they so wish. +*/ +cond_resched (); + + last_sample = sample; + last_int_count = int_count; + + }while (total < runtime && !kthread_should_stop ()); + +/* +* Finish the above in the view for interrupts. +*/ +barrier (); + + osn_var->sampling = false; + +/* +* Make sure sampling data is no longer updated. +*/ +barrier (); + +/* +* Save noise info. +*/ + s.noise =time_to_us (sum_noise); + s.runtime =time_to_us (total); + s.max_sample =time_to_us (max_noise); + s.hw_count = hw_count; + +/* Save interference stats info */ +diff_osn_sample_stats (osn_var, &s); + +trace_osnoise_sample (&s); + +/* Keep a running maximum ever recorded osnoise "latency" */ +if (max_noise > tr->max_latency) { + tr->max_latency = max_noise; +latency_fsnotify (tr); + } + +if (osnoise_data.stop_tracing_out) +if (s.noise > osnoise_data.stop_tracing_out) +osnoise_stop_tracing (); + +return 0 ; +out: +return ret; +} + +static struct cpumask osnoise_cpumask; +static struct cpumask save_cpumask; + +/* +* osnoise_main - The osnoise detection kernel thread +* +* Calls run_osnoise() function to measure the osnoise for the configured runtime, +* every period. +*/ +static int osnoise_main (void *data) +{ +s64 interval; + +while (!kthread_should_stop ()) { + +run_osnoise (); + +mutex_lock (&interface_lock); + interval = osnoise_data.sample_period - osnoise_data.sample_runtime; +mutex_unlock (&interface_lock); + +do_div (interval,USEC_PER_MSEC ); +
Quoted 8 lines
kernel/trace/trace_osnoise.c line 1173
Quoted 3 lines
kernel/trace/trace_osnoise.c new file +3
-0+/* +* differently from hwlat_detector, the osnoise tracer can run +* without a pause because preemption is on. Can it? With !CONFIG_PREEMPT, this will never sleep, right? I believe there's watchdogs that will trigger if a kernel thread never schedules out. I might be wrong, will have to check on this.
There is a cond_resched() in the run_noise() loop. Thus making osnoise "preemptible," allowing other threads to run (and to interfere).
Quoted 62 lines
Quoted 47 lines
kernel/trace/trace_osnoise.c new file +46
-0+*/ +if (interval <1 ) +continue ; + +if (msleep_interruptible (interval)) +break ; + } + +return 0 ; +} + +/** +* stop_per_cpu_kthread - stop per-cpu threads +* +* Stop the osnoise sampling htread. Use this on unload and at system +* shutdown. +*/ +static void stop_per_cpu_kthreads (void ) +{ +struct task_struct *kthread; +int cpu; + +for_each_online_cpu (cpu) { + kthread =per_cpu (per_cpu_osnoise_var, cpu).kthread; +if (kthread) +kthread_stop (kthread); +per_cpu (per_cpu_osnoise_var, cpu).kthread =NULL ; + } +} + +/** +* start_per_cpu_kthread - Kick off per-cpu osnoise sampling kthreads +* +* This starts the kernel thread that will look for osnoise on many +* cpus. +*/ +static int start_per_cpu_kthreads (struct trace_array *tr) +{ +struct cpumask *current_mask = &save_cpumask; +struct task_struct *kthread; +char comm[24 ]; +int cpu; + +get_online_cpus (); +/* +* Run only on CPUs in which trace and osnoise are allowed to run. kernel/trace/trace_osnoise.c line 1229
Quoted 10 lines
kernel/trace/trace_osnoise.c new file +10
-0+*/ +cpumask_and (current_mask, tr->tracing_cpumask, &osnoise_cpumask); +/* +* And the CPU is online. +*/ +cpumask_and (current_mask, cpu_online_mask, current_mask); +put_online_cpus (); + +for_each_online_cpu (cpu) +per_cpu (per_cpu_osnoise_var, cpu).kthread =NULL ;I think we want
for_each_possible_cpu(), especially since you don't have anything protecting the online cpus here since you didput_online_cpus. But still, we probably want them all NULL anyway.
Quoted 2 lines
Should this have a CPU shutdown notifier, to clean things up if this is running while people are playing with CPU hotplug?
well.... it seems to be worth trying! Question can I take a mutex on the hp callback? (it will be the interface mutex).
Quoted 79 lines
Quoted 79 lines
kernel/trace/trace_osnoise.c new file +78
-0+ +for_each_cpu (cpu, current_mask) { +snprintf (comm,24 ,"osnoise/%d" , cpu); + + kthread =kthread_create_on_cpu (osnoise_main,NULL , cpu, comm); + +if (IS_ERR (kthread)) { +pr_err (BANNER "could not start sampling thread\n" ); +stop_per_cpu_kthreads (); +return -ENOMEM ; + } + +per_cpu (per_cpu_osnoise_var, cpu).kthread = kthread; +wake_up_process (kthread); + } + +return 0 ; +} + +/* +* osnoise_cpus_read - Read function for reading the "cpus" file +* @filp: The active open file structure +* @ubuf: The userspace provided buffer to read value into +* @cnt: The maximum number of bytes to read +* @ppos: The current "file" position +* +* Prints the "cpus" output into the user-provided buffer. +*/ +static ssize_t +osnoise_cpus_read (struct file *filp,char __user *ubuf,size_t count, +loff_t *ppos) +{ +char *mask_str; +int len; + + len =snprintf (NULL ,0 ,"%*pbl\n" , +cpumask_pr_args (&osnoise_cpumask)) +1 ; + mask_str =kmalloc (len,GFP_KERNEL ); +if (!mask_str) +return -ENOMEM ; + + len =snprintf (mask_str, len,"%*pbl\n" , +cpumask_pr_args (&osnoise_cpumask)); +if (len >= count) { + count = -EINVAL ; + goto out_err; + } + count =simple_read_from_buffer (ubuf, count, ppos, mask_str, len); + +out_err: +kfree (mask_str); + +return count; +} + +/** +* osnoise_cpus_write - Write function for "cpus" entry +* @filp: The active open file structure +* @ubuf: The user buffer that contains the value to write +* @cnt: The maximum number of bytes to write to "file" +* @ppos: The current position in @file +* +* This function provides a write implementation for the "cpus" +* interface to the osnoise trace. By default, it lists all CPUs, +* in this way, allowing osnoise threads to run on any online CPU +* of the system. It serves to restrict the execution of osnoise to the +* set of CPUs writing via this interface. Note that osnoise also +* respects the "tracing_cpumask." Hence, osnoise threads will run only +* on the set of CPUs allowed here AND on "tracing_cpumask." Why not +* have just "tracing_cpumask?" Because the user might be interested +* in tracing what is running on other CPUs. For instance, one might +* run osnoise in one HT CPU while observing what is running on the +* sibling HT CPU. +*/ +static ssize_t +osnoise_cpus_write (struct file *filp,const char __user *ubuf,size_t count, +loff_t *ppos) +{
Quoted 8 lines
kernel/trace/trace_osnoise.c line 1311
Quoted 4 lines
kernel/trace/trace_osnoise.c new file +4
-0+cpumask_var_t osnoise_cpumask_new; +char buf[256 ]; +int err; +Since this does not affect a running osnoise tracer, we should either have it return BUSY if it is running, or have it update the threads during the run.
I will do the same thing I did (as your request) for hwlat's mode: I will stop/start the tracer to apply the changes.
Thanks Steven!
-- Daniel
Steven Rostedt
maintainerRe: [PATCH V3 8/9] tracing: Add osnoise tracer
Quoted 11 lines · On Mon, 7 Jun 2021 14:00:56 +0200 Daniel Bristot de Oliveira…
I am using these more "generic terms" because they are also used by the timerlat tracer.
In the timerlat tracer, the "in" file is used to stop the tracer for a given IRQ latency (so, the "inside" operation), while the "out" is used to stop the tracer in the thread latency (hence the outside operation).
The total sounds good for the "out"! But the single does not work fine for the IRQ... how about:
stop_tracing_partial_us?It is hard to find a good shared name :-/
What about:
stop_tracing_us and stop_tracing_total_us, and not have anything special for the first one?
-- Steve
Re: [PATCH V3 8/9] tracing: Add osnoise tracer
Quoted 7 lines · Steven Rostedt
Quoted 7 lines
I am using these more "generic terms" because they are also used by the timerlat tracer.
In the timerlat tracer, the "in" file is used to stop the tracer for a given IRQ latency (so, the "inside" operation), while the "out" is used to stop the tracer in the thread latency (hence the outside operation).
Quoted 8 lines
Quoted 4 lines
The total sounds good for the "out"! But the single does not work fine for the IRQ... how about:
stop_tracing_partial_us?It is hard to find a good shared name :-/
What about:
stop_tracing_usandstop_tracing_total_us, and not have anything special for the first one?
I cannot find a better name... and it makes sense: if an "in" value on osnoise or an IRQ latency on timerlat is higher than "stop_tracing_us"... it is more important than the total... so it indeed deserves the more intuitive name.
(working on osnoise changes now...)
-- Daniel
Quoted 2 lines
-- Steve
Re: [PATCH V3 8/9] tracing: Add osnoise tracer
In reply to Steven RostedtQuoted 4 lines · Steven Rostedt
Quoted 4 lines
kernel/trace/trace_osnoise.c new file +4
-0+/* +* This is an evidence of race conditions that cause +* a value to be "discounted" too much. +*/
Quoted 8 lines
kernel/trace/trace_osnoise.c line 341
Quoted 2 lines
kernel/trace/trace_osnoise.c new file +2
-0+if (duration <0 ) +pr_err ("int safe negative!\n" );Probably want to have this happen at most once a run. If something were to break, I don't think we want this to live lock the machine doing tons of prints. We could have a variable stored on the
osnoise_variablesthat states this was printed. Check that variable to see if it wasn't printed during a run (whencurrent_tracerwas set), and print only once if it is.
I created a "bool tainted" variable, that is set true if any problem with time() related functions happen. I will pr_warn that there is a problem on _start(), but also print this info at the top of the tracer header, so it is clear also from the trace output.
Thoughts?
-- Daniel
Steven Rostedt
maintainerRe: [PATCH V3 8/9] tracing: Add osnoise tracer
Quoted 14 lines · On Tue, 8 Jun 2021 19:17:55 +0200 Daniel Bristot de Oliveira…
Quoted 4 lines · Steven Rostedt
Quoted 4 lines
kernel/trace/trace_osnoise.c new file +4
-0+/* +* This is an evidence of race conditions that cause +* a value to be "discounted" too much. +*/ Quoted 8 lines
kernel/trace/trace_osnoise.c line 341
Quoted 2 lines
kernel/trace/trace_osnoise.c new file +2
-0+if (duration <0 ) +pr_err ("int safe negative!\n" );Probably want to have this happen at most once a run. If something were to break, I don't think we want this to live lock the machine doing tons of prints. We could have a variable stored on the
osnoise_variablesthat states this was printed. Check that variable to see if it wasn't printed during a run (whencurrent_tracerwas set), and print only once if it is.
Quoted 7 lines
I created a "bool tainted" variable, that is set true if any problem with
time()related functions happen. I willpr_warnthat there is a problem on_start(), but also print this info at the top of the tracer header, so it is clear also from the trace output.Thoughts?
Or perhaps have that pr_err() actually be written into the trace buffer?
You can use
trace_array_printk_buf(tr->array_buffer.buffer, _THIS_IP_, "string");
without it triggering that nasty trace_printk() notice ;-)
-- Steve
Re: [PATCH V3 8/9] tracing: Add osnoise tracer
Quoted 7 lines · Steven Rostedt
Quoted 7 lines
I created a "bool tainted" variable, that is set true if any problem with
time()related functions happen. I willpr_warnthat there is a problem on_start(), but also print this info at the top of the tracer header, so it is clear also from the trace output.Thoughts?
Quoted 7 lines
Or perhaps have that
pr_err()actually be written into the trace buffer?You can use
trace_array_printk_buf(tr->array_buffer.buffer, _THIS_IP_, "string");without it triggering that nasty
trace_printk()notice ;-)
cool! I created a function osnoise_taint(char *msg) that prints the msg using trace_array_printk_buf. I am using it instead of all pr_warn that could take place inside osnoise regular operation.
I am still placing the note in the header, just in case we miss the message in the log.
-- Daniel
Quoted 2 lines
-- Steve
Steven Rostedt
maintainerRe: [PATCH V3 8/9] tracing: Add osnoise tracer
Quoted 3 lines · On Tue, 8 Jun 2021 21:33:31 +0200 Daniel Bristot de Oliveira…
cool! I created a function
osnoise_taint(char *msg)that prints the msg usingtrace_array_printk_buf. I am using it instead of allpr_warnthat could take place inside osnoise regular operation.
Make it a macro, so that _THIS_IP_ is meaningful.
Quoted 3 lines
I am still placing the note in the header, just in case we miss the message in the log.
+1
-- Steve
Re: [PATCH V3 8/9] tracing: Add osnoise tracer
In reply to Steven RostedtQuoted 5 lines · Steven Rostedt
Quoted 1 line
+#ifdef
CONFIG_X86_LOCAL_APICI wonder if we should move this into a separate file, making the
__trace_irq_entry()a more name space safe name and have it call that. I have a bit of a distaste for arch specific code in a generic file.
I am placing the intel specific file in:
arch/x86/kernel/trace_osnoise.c
and the kernel/trace/trace_osnoise.h looks like this:
#ifdef CONFIG_X86_LOCAL_APIC
int osnoise_arch_register(void);
int osnoise_arch_unregister(void);
#else /* CONFIG_X86_LOCAL_APIC */
#define osnoise_arch_register() do {} while (0)
#define osnoise_arch_unregister() do {} while (0)
#endif /* CONFIG_X86_LOCAL_APIC */
This can be used by other archs as well...
sound reasonable?
-- Daniel
Quoted 8 lines
Quoted 8 lines
kernel/trace/trace_osnoise.c new file +8
-0+/** +* trace_intel_irq_entry - record intel specific IRQ entry +*/ +void trace_intel_irq_entry (void *data,int vector) +{ +__trace_irq_entry (vector); +} +
Steven Rostedt
maintainerRe: [PATCH V3 8/9] tracing: Add osnoise tracer
Quoted 10 lines · On Wed, 9 Jun 2021 14:14:17 +0200 Daniel Bristot de Oliveira…
Quoted 5 lines · Steven Rostedt
Quoted 1 line
+#ifdef
CONFIG_X86_LOCAL_APICI wonder if we should move this into a separate file, making the
__trace_irq_entry()a more name space safe name and have it call that. I have a bit of a distaste for arch specific code in a generic file.I am placing the intel specific file in:
arch/x86/kernel/trace_osnoise.c
I would make it just arch/x86/kernel/trace.c
so that it can hold all arch specific tracing information, and not need to create a file for anything else we might need later.
Quoted 11 lines
and the
kernel/trace/trace_osnoise.hlooks like this:#ifdef
CONFIG_X86_LOCAL_APIC
intosnoise_arch_register(void);
intosnoise_arch_unregister(void);
#else /*CONFIG_X86_LOCAL_APIC*/
#defineosnoise_arch_register()do {} while (0)
#defineosnoise_arch_unregister()do {} while (0)
#endif /*CONFIG_X86_LOCAL_APIC*/
Quoted 4 lines
This can be used by other archs as well...
sound reasonable?
The proper way to d that is to use weak functions in the C code in the generic file.
int __weak osnoise_arch_register(void)
{
return 0;
}int __weak osnoise_arch_unregister(void)
{
return 0;
}Hmm, does the unregister really need a return value?
-- Steve
Re: [PATCH V3 8/9] tracing: Add osnoise tracer
Quoted 10 lines · Steven Rostedt
Quoted 7 lines · On Wed, 9 Jun 2021 14:14:17 +0200 Daniel Bristot de Oliveira…
Quoted 5 lines · Steven Rostedt
Quoted 1 line
+#ifdef
CONFIG_X86_LOCAL_APICI wonder if we should move this into a separate file, making the
__trace_irq_entry()a more name space safe name and have it call that. I have a bit of a distaste for arch specific code in a generic file.
Quoted 5 lines
Quoted 3 lines
I am placing the intel specific file in:
arch/x86/kernel/trace_osnoise.cI would make it just
arch/x86/kernel/trace.c
moved!
Quoted 27 lines
so that it can hold all arch specific tracing information, and not need to create a file for anything else we might need later.
Quoted 11 lines
and the
kernel/trace/trace_osnoise.hlooks like this:#ifdef
CONFIG_X86_LOCAL_APIC
intosnoise_arch_register(void);
intosnoise_arch_unregister(void);
#else /*CONFIG_X86_LOCAL_APIC*/
#defineosnoise_arch_register()do {} while (0)
#defineosnoise_arch_unregister()do {} while (0)
#endif /*CONFIG_X86_LOCAL_APIC*/Quoted 4 lines
This can be used by other archs as well...
sound reasonable?
The proper way to d that is to use weak functions in the C code in the generic file.
int
__weakosnoise_arch_register(void){ return 0; }
Quoted 6 lines
int
__weakosnoise_arch_unregister(void){ return 0; }Hmm, does the unregister really need a return value?
it was always returning 0, changed it to void.
-- Daniel
PATCH v3 9/9 tracing: Add timerlat tracer
In reply to Daniel Bristot de OliveiraThe timerlat tracer aims to help the preemptive kernel developers to found souces of wakeup latencies of real-time threads. Like cyclictest, the tracer sets a periodic timer that wakes up a thread. The thread then computes a *wakeup latency* value as the difference between the *current time* and the *absolute time* that the timer was set to expire. The main goal of timerlat is tracing in such a way to help kernel developers.
Usage
Write the ASCII text "timerlat" into the current_tracer file of the tracing system (generally mounted at /sys/kernel/tracing).
For example:
[root@f32 ~]# cd /sys/kernel/tracing/ [root@f32 tracing]# echo timerlat > current_tracer
It is possible to follow the trace by reading the trace trace file::
[root@f32 tracing]# cat trace
# tracer: timerlat
#
# _-----=> irqs-off
# / _----=> need-resched
# | / _---=> hardirq/softirq
# || / _--=> preempt-depth
# || /
# |||| ACTIVATION
# TASK-PID CPU# |||| TIMESTAMP ID CONTEXT LATENCY
# | | | |||| | | | |
<idle>-0 [000] d.h1 54.029328: #1 context irq timer_latency 932 ns
<...>-867 [000] .... 54.029339: #1 context thread timer_latency 11700 ns
<idle>-0 [001] dNh1 54.029346: #1 context irq timer_latency 2833 ns
<...>-868 [001] .... 54.029353: #1 context thread timer_latency 9820 ns
<idle>-0 [000] d.h1 54.030328: #2 context irq timer_latency 769 ns
<...>-867 [000] .... 54.030330: #2 context thread timer_latency 3070 ns
<idle>-0 [001] d.h1 54.030344: #2 context irq timer_latency 935 ns
<...>-868 [001] .... 54.030347: #2 context thread timer_latency 4351 nsThe tracer creates a per-cpu kernel thread with real-time priority that prints two lines at every activation. The first is the *timer latency* observed at the *hardirq* context before the activation of the thread. The second is the *timer latency* observed by the thread, which is the same level that cyclictest reports. The ACTIVATION ID field serves to relate the *irq* execution to its respective *thread* execution.
The irq/thread splitting is important to clarify at which context the unexpected high value is coming from. The *irq* context can be delayed by hardware related actions, such as SMIs, NMIs, IRQs or by a thread masking interrupts. Once the timer happens, the delay can also be influenced by blocking caused by threads. For example, by postponing the scheduler execution via preempt_disable(), by the scheduler execution, or by masking interrupts. Threads can also be delayed by the interference from other threads and IRQs.
The timerlat can also take advantage of the osnoise: traceevents. For example:
[root@f32 ~]# cd /sys/kernel/tracing/
[root@f32 tracing]# echo timerlat > current_tracer
[root@f32 tracing]# echo osnoise > set_event
[root@f32 tracing]# echo 25 > osnoise/stop_tracing_out_us
[root@f32 tracing]# tail -10 trace
cc1-87882 [005] d..h... 548.771078: #402268 context irq timer_latency 1585 ns
cc1-87882 [005] dNLh1.. 548.771082: irq_noise: local_timer:236 start 548.771077442 duration 4597 ns
cc1-87882 [005] dNLh2.. 548.771083: irq_noise: reschedule:253 start 548.771083017 duration 56 ns
cc1-87882 [005] dNLh2.. 548.771086: irq_noise: call_function_single:251 start 548.771083811 duration 2048 ns
cc1-87882 [005] dNLh2.. 548.771088: irq_noise: call_function_single:251 start 548.771086814 duration 1495 ns
cc1-87882 [005] dNLh2.. 548.771091: irq_noise: call_function_single:251 start 548.771089194 duration 1558 ns
cc1-87882 [005] dNLh2.. 548.771094: irq_noise: call_function_single:251 start 548.771091719 duration 1932 ns
cc1-87882 [005] dNLh2.. 548.771096: irq_noise: call_function_single:251 start 548.771094696 duration 1050 ns
cc1-87882 [005] d...3.. 548.771101: thread_noise: cc1:87882 start 548.771078243 duration 10909 ns
timerlat/5-1035 [005] ....... 548.771103: #402268 context thread timer_latency 25960 nsFor further information see: Documentation/trace/timerlat-tracer.rst
--- Documentation/trace/index.rst | 1 + Documentation/trace/timerlat-tracer.rst | 158 ++++++ kernel/trace/Kconfig | 28 ++ kernel/trace/trace.h | 2 + kernel/trace/trace_entries.h | 16 + kernel/trace/trace_osnoise.c | 625 ++++++++++++++++++++++-- kernel/trace/trace_output.c | 47 ++ 7 files changed, 846 insertions(+), 31 deletions(-) create mode 100644 Documentation/trace/timerlat-tracer.rst
Documentation/trace/index.rst +1 -0
@@ -24,6 +24,7 @@ Linux Tracing Technologies boottime-trace hwlat_detector osnoise-tracer + timerlat-tracer intel_th ring-buffer-design stm
Documentation/trace/timerlat-tracer.rst new file +158 -0
158 lines not on this page · raw message
kernel/trace/Kconfig +28 -0
@@ -390,6 +390,34 @@ config OSNOISE_TRACER To enable this tracer, echo in "osnoise" into the current_tracer file. +config TIMERLAT_TRACER + bool "Timerlat tracer" + select OSNOISE_TRACER + select GENERIC_TRACER + help + The timerlat tracer aims to help the preemptive kernel developers + to find sources of wakeup latencies of real-time threads. + + The tracer creates a per-cpu kernel thread with real-time priority. + The tracer thread sets a periodic timer to wakeup itself, and goes + to sleep waiting for the timer to fire. At the wakeup, the thread + then computes a wakeup latency value as the difference between + the current time and the absolute time that the timer was set + to expire. + + The tracer prints two lines at every activation. The first is the + timer latency observed at the hardirq context before the + activation of the thread. The second is the timer latency observed + by the thread, which is the same level that cyclictest reports. The + ACTIVATION ID field serves to relate the irq execution to its + respective thread execution. + + The tracer is build on top of osnoise tracer, and the osnoise: + events can be used to trace the source of interference from NMI, + IRQs and other threads. It also enables the capture of the + stacktrace at the IRQ context, which helps to identify the code + path that can cause thread delay. + config MMIOTRACE bool "Memory mapped IO tracing" depends on HAVE_MMIOTRACE_SUPPORT && PCI
kernel/trace/trace.h +2 -0
@@ -45,6 +45,7 @@ enum trace_type {TRACE_BPUTS ,TRACE_HWLAT ,TRACE_OSNOISE , +TRACE_TIMERLAT ,TRACE_RAW_DATA , TRACE_FUNC_REPEATS,
@@ -448,6 +449,7 @@ extern void __ftrace_bad_type(void); IF_ASSIGN(var, ent, struct bputs_entry, TRACE_BPUTS); \ IF_ASSIGN(var, ent, struct hwlat_entry, TRACE_HWLAT); \ IF_ASSIGN(var, ent, struct osnoise_entry, TRACE_OSNOISE);\ + IF_ASSIGN(var, ent, struct timerlat_entry, TRACE_TIMERLAT);\ IF_ASSIGN(var, ent, struct raw_data_entry, TRACE_RAW_DATA);\ IF_ASSIGN(var, ent, struct trace_mmiotrace_rw, \TRACE_MMIO_RW ); \
kernel/trace/trace_entries.h +16 -0
@@ -385,3 +385,19 @@ FTRACE_ENTRY(osnoise, osnoise_entry, __entry->softirq_count, __entry->thread_count) ); + +FTRACE_ENTRY (timerlat, timerlat_entry, + +TRACE_TIMERLAT , + +F_STRUCT ( + __field( unsigned int, seqnum ) + __field( int, context ) +__field ( u64, timer_latency ) + ), + +F_printk ("seq:%u\tcontext:%d\ttimer_latency:%llu\n" , + __entry->seqnum, + __entry->context, + __entry->timer_latency) +);
kernel/trace/trace_osnoise.c +594 -31
808 lines not on this page · raw message
kernel/trace/trace_output.c +47 -0
59 lines not on this page · raw message
Signature · 1 line
2.26.3
Steven Rostedt
maintainerRe: [PATCH V3 9/9] tracing: Add timerlat tracer
Quoted 7 lines · On Fri, 14 May 2021 22:51:18 +0200 Daniel Bristot de Oliveira…
The timerlat tracer aims to help the preemptive kernel developers to found souces of wakeup latencies of real-time threads. Like cyclictest, the tracer sets a periodic timer that wakes up a thread. The thread then computes a *wakeup latency* value as the difference between the *current time* and the *absolute time* that the timer was set to expire. The main goal of timerlat is tracing in such a way to help kernel developers.
Hmm, we should add a way to have wake up tracers only trace a specific task, where these osnoise trace events would also be useful. That is, run cyclictest with the wakeup tracer, that it does this for cyclictest directly. That shouldn't be too difficult to add.
Quoted 11 lines
Usage
Write the ASCII text "timerlat" into the
current_tracerfile of the tracing system (generally mounted at/sys/kernel/tracing).For example:
[root@f32 ~]# cd
/sys/kernel/tracing/[root@f32 tracing]# echo timerlat >current_tracerIt is possible to follow the trace by reading the trace trace file::
Do not need rst markup in commit logs ;-)
Quoted 21 lines
[root@f32 tracing]# cat trace
# tracer: timerlat
#
# _-----=> irqs-off
# / _----=> need-resched# | / _---=> hardirq/softirq # || / _--=> preempt-depth # || / # |||| ACTIVATION # TASK-PID CPU# |||| TIMESTAMP ID CONTEXT LATENCY # | | | |||| | | | | <idle>-0 [000] d.h1 54.029328: #1 context irq timer_latency 932 ns <...>-867 [000] .... 54.029339: #1 context thread timer_latency 11700 ns <idle>-0 [001] dNh1 54.029346: #1 context irq timer_latency 2833 ns <...>-868 [001] .... 54.029353: #1 context thread timer_latency 9820 ns <idle>-0 [000] d.h1 54.030328: #2 context irq timer_latency 769 ns <...>-867 [000] .... 54.030330: #2 context thread timer_latency 3070 ns <idle>-0 [001] d.h1 54.030344: #2 context irq timer_latency 935 ns <...>-868 [001] .... 54.030347: #2 context thread timer_latency 4351 ns
Quoted 5 lines
The tracer creates a per-cpu kernel thread with real-time priority that prints two lines at every activation. The first is the *timer latency* observed at the *hardirq* context before the activation of the thread. The second is the *timer latency* observed by the thread, which is the same level that cyclictest reports. The ACTIVATION ID field
The above is misleading. Below, I see that you state that the values are "net values" where the thread latency does not include the irq latency. This is not the same as cyclictest. (I had to update my ASCII art below after reading the below statement).
Quoted 10 lines
serves to relate the *irq* execution to its respective *thread* execution.
The irq/thread splitting is important to clarify at which context the unexpected high value is coming from. The *irq* context can be delayed by hardware related actions, such as SMIs, NMIs, IRQs or by a thread masking interrupts. Once the timer happens, the delay can also be influenced by blocking caused by threads. For example, by postponing the scheduler execution via
preempt_disable(), by the scheduler execution, or by masking interrupts. Threads can also be delayed by the interference from other threads and IRQs.
I wonder if ASCII art would help clarify the above. At least for the document (not the change log here).
time ==>
expected actual thread
wakeup wakeup scheduled
| | |
v v v
|---------|-------|------|----------|
^
|
interrupt
|--------------|
irq latency
|-----------|
thread latencyQuoted 43 lines
The timerlat can also take advantage of the osnoise: traceevents. For example:
[root@f32 ~]# cd /sys/kernel/tracing/ [root@f32 tracing]# echo timerlat > current_tracer [root@f32 tracing]# echo osnoise > set_event [root@f32 tracing]# echo 25 > osnoise/stop_tracing_out_us [root@f32 tracing]# tail -10 trace cc1-87882 [005] d..h... 548.771078: #402268 context irq timer_latency 1585 ns cc1-87882 [005] dNLh1.. 548.771082: irq_noise: local_timer:236 start 548.771077442 duration 4597 ns cc1-87882 [005] dNLh2.. 548.771083: irq_noise: reschedule:253 start 548.771083017 duration 56 ns cc1-87882 [005] dNLh2.. 548.771086: irq_noise: call_function_single:251 start 548.771083811 duration 2048 ns cc1-87882 [005] dNLh2.. 548.771088: irq_noise: call_function_single:251 start 548.771086814 duration 1495 ns cc1-87882 [005] dNLh2.. 548.771091: irq_noise: call_function_single:251 start 548.771089194 duration 1558 ns cc1-87882 [005] dNLh2.. 548.771094: irq_noise: call_function_single:251 start 548.771091719 duration 1932 ns cc1-87882 [005] dNLh2.. 548.771096: irq_noise: call_function_single:251 start 548.771094696 duration 1050 ns cc1-87882 [005] d...3.. 548.771101: thread_noise: cc1:87882 start 548.771078243 duration 10909 ns timerlat/5-1035 [005] ....... 548.771103: #402268 context thread timer_latency 25960 nsFor further information see:
Documentation/trace/timerlat-tracer.rstDocumentation/trace/index.rst +1
-0@@ -24,6 +24,7 @@ Linux Tracing Technologies boottime-trace hwlat_detector osnoise-tracer + timerlat-tracer intel_th ring-buffer-design stmDocumentation/trace/timerlat-tracer.rst new file +0
-0
Documentation/trace/timerlat-tracer.rst line 6
Quoted 6 lines
Documentation/trace/timerlat-tracer.rst new file +6
-0@@ -0,0 +1,158 @@ +############### +Timerlat tracer +############### + +The timerlat tracer aims to help the preemptive kernel developers to +found souces of wakeup latencies of real-time threads. Like cyclictest,
"to find sources"
Quoted 44 lines
Documentation/trace/timerlat-tracer.rst new file +44
-0+the tracer sets a periodic timer that wakes up a thread. The thread then +computes a *wakeup latency* value as the difference between the *current +time* and the *absolute time* that the timer was set to expire. The main +goal of timerlat is tracing in such a way to help kernel developers. + +Usage +----- + +Write the ASCII text "timerlat" into the current_tracer file of the +tracing system (generally mounted at /sys/kernel/tracing). + +For example:: + + [root@f32 ~]# cd /sys/kernel/tracing/ + [root@f32 tracing]# echo timerlat > current_tracer + +It is possible to follow the trace by reading the trace trace file:: + + [root@f32 tracing]# cat trace + # tracer: timerlat + # + # _-----=> irqs-off + # / _----=> need-resched + # | / _---=> hardirq/softirq + # || / _--=> preempt-depth + # || / + # |||| ACTIVATION + # TASK-PID CPU# |||| TIMESTAMP ID CONTEXT LATENCY + # | | | |||| | | | | + <idle>-0 [000] d.h1 54.029328: #1 context irq timer_latency 932 ns + <...>-867 [000] .... 54.029339: #1 context thread timer_latency 11700 ns + <idle>-0 [001] dNh1 54.029346: #1 context irq timer_latency 2833 ns + <...>-868 [001] .... 54.029353: #1 context thread timer_latency 9820 ns + <idle>-0 [000] d.h1 54.030328: #2 context irq timer_latency 769 ns + <...>-867 [000] .... 54.030330: #2 context thread timer_latency 3070 ns + <idle>-0 [001] d.h1 54.030344: #2 context irq timer_latency 935 ns + <...>-868 [001] .... 54.030347: #2 context thread timer_latency 4351 ns + + +The tracer creates a per-cpu kernel thread with real-time priority that +prints two lines at every activation. The first is the *timer latency* +observed at the *hardirq* context before the activation of the thread. +The second is the *timer latency* observed by the thread, which is the +same level that cyclictest reports. The ACTIVATION ID field
Documentation/trace/timerlat-tracer.rst line 60
Quoted 10 lines
Documentation/trace/timerlat-tracer.rst new file +10
-0+serves to relate the *irq* execution to its respective *thread* execution. + +The *irq*/*thread* splitting is important to clarify at which context +the unexpected high value is coming from. The *irq* context can be +delayed by hardware related actions, such as SMIs, NMIs, IRQs +or by a thread masking interrupts. Once the timer happens, the delay +can also be influenced by blocking caused by threads. For example, by +postponing the scheduler execution via preempt_disable(), by the +scheduler execution, or by masking interrupts. Threads can +also be delayed by the interference from other threads and IRQs.
This is where I would add that ASCII art.
Quoted 8 lines
Documentation/trace/timerlat-tracer.rst new file +8
-0+ +Tracer options +--------------------- + +The timerlat tracer is built on top of osnoise tracer. +So its configuration is also done in the osnoise/ config +directory. The timerlat configs are: +
Documentation/trace/timerlat-tracer.rst line 78
Quoted 10 lines
Documentation/trace/timerlat-tracer.rst new file +10
-0+ - cpus: CPUs at which a timerlat thread will execute. + - timerlat_period_us: the period of the timerlat thread. + - osnoise/stop_tracing_in_us: stop the system tracing if a + timer latency at the *irq* context higher than the configured + value happens. Writing 0 disables this option. + - stop_tracing_out_us: stop the system tracing if a + timer latency at the *thread* context higher than the configured + value happens. Writing 0 disables this option. + - print_stack: save the stack of the IRQ ocurrence, and print + it after the *thread* read the latency.
"thread read the latency" doesn't make sense.
"and print it after the *thread context* event". ?
Documentation/trace/timerlat-tracer.rst line 88
Quoted 10 lines
Documentation/trace/timerlat-tracer.rst new file +10
-0+ +timerlat and osnoise +---------------------------- + +The timerlat can also take advantage of the osnoise: traceevents. +For example:: + + [root@f32 ~]# cd /sys/kernel/tracing/ + [root@f32 tracing]# echo timerlat > current_tracer + [root@f32 tracing]# echo osnoise > set_event
Note, set_event should be deprecated. Use:
echo 1 > events/osnoise/enable
instead.
Quoted 5 lines
Documentation/trace/timerlat-tracer.rst new file +5
-0+ [root@f32 tracing]# echo 25 > osnoise/stop_tracing_out_us + [root@f32 tracing]# tail -10 trace + cc1-87882 [005] d..h... 548.771078: #402268 context irq timer_latency 1585 ns + cc1-87882 [005] dNLh1.. 548.771082: irq_noise: local_timer:236 start 548.771077442 duration 4597 ns + cc1-87882 [005] dNLh2.. 548.771083: irq_noise: reschedule:253 start 548.771083017 duration 56 ns
Documentation/trace/timerlat-tracer.rst line 103
Quoted 10 lines
Documentation/trace/timerlat-tracer.rst new file +10
-0+ cc1-87882 [005] dNLh2.. 548.771086: irq_noise: call_function_single:251 start 548.771083811 duration 2048 ns + cc1-87882 [005] dNLh2.. 548.771088: irq_noise: call_function_single:251 start 548.771086814 duration 1495 ns + cc1-87882 [005] dNLh2.. 548.771091: irq_noise: call_function_single:251 start 548.771089194 duration 1558 ns + cc1-87882 [005] dNLh2.. 548.771094: irq_noise: call_function_single:251 start 548.771091719 duration 1932 ns + cc1-87882 [005] dNLh2.. 548.771096: irq_noise: call_function_single:251 start 548.771094696 duration 1050 ns + cc1-87882 [005] d...3.. 548.771101: thread_noise: cc1:87882 start 548.771078243 duration 10909 ns + timerlat/5-1035 [005] ....... 548.771103: #402268 context thread timer_latency 25960 ns + +In this case, the root cause of the timer latency does not point for a +single, but to a series of call_function_single IPIs, followed by a 10
"not point to a single"
Documentation/trace/timerlat-tracer.rst line 108
Quoted 5 lines
Documentation/trace/timerlat-tracer.rst new file +5
-0+*us* delay from a cc1 thread noise, along with the regular timer +activation. It is worth mentioning that the *duration* values reported +by the osnoise events are *net* values. For example, the +thread_noise does not include the duration of the overhead caused +by the IRQ execution (which indeed accounted for 12736 ns).
As stated above, I updated my view of the ASCII art after reading this. You should not compare what cyclictest reports as the thread latency. But what cyclictest reports is the sum of the two (irq latency plus thread latency).
Quoted 31 lines
Documentation/trace/timerlat-tracer.rst new file +31
-0+ +Such pieces of evidence are useful for the developer to use other +tracing methods to figure out how to optimize the environment. + +IRQ stacktrace +--------------------------- + +The osnoise/print_stack option is helpful for the cases in which a thread +noise causes the major factor for the timer latency, because of preempt or +irq disabled. For example:: + + [root@f32 tracing]# echo 500 > osnoise/stop_tracing_out_us + [root@f32 tracing]# echo 500 > osnoise/print_stack + [root@f32 tracing]# echo timerlat > current_tracer + [root@f32 tracing]# tail -21 per_cpu/cpu7/trace + insmod-1026 [007] dN.h1.. 200.201948: irq_noise: local_timer:236 start 200.201939376 duration 7872 ns + insmod-1026 [007] d..h1.. 200.202587: #29800 context irq timer_latency 1616 ns + insmod-1026 [007] dN.h2.. 200.202598: irq_noise: local_timer:236 start 200.202586162 duration 11855 ns + insmod-1026 [007] dN.h3.. 200.202947: irq_noise: local_timer:236 start 200.202939174 duration 7318 ns + insmod-1026 [007] d...3.. 200.203444: thread_noise: insmod:1026 start 200.202586933 duration 838681 ns + timerlat/7-1001 [007] ....... 200.203445: #29800 context thread timer_latency 859978 ns + timerlat/7-1001 [007] ....1.. 200.203446: <stack trace> + => timerlat_irq + => __hrtimer_run_queues + => hrtimer_interrupt + => __sysvec_apic_timer_interrupt + => asm_call_irq_on_stack + => sysvec_apic_timer_interrupt + => asm_sysvec_apic_timer_interrupt + => delay_tsc + => dummy_load_1ms_pd_init
Documentation/trace/timerlat-tracer.rst line 149
Quoted 10 lines
Documentation/trace/timerlat-tracer.rst new file +10
-0+ => do_one_initcall + => do_init_module + => __do_sys_finit_module + => do_syscall_64 + => entry_SYSCALL_64_after_hwframe + +In this case, it is possible to see that the thread added the highest +contribution to the *timer latency* and the stack trace points to +a function named dummy_load_1ms_pd_init, which had the following +code (on purpose)::
Should add here as well that the stack is saved at the time of interrupt, and not at the time it is reported.
Quoted 26 lines
Documentation/trace/timerlat-tracer.rst new file +9
-0+ + static int __init dummy_load_1ms_pd_init(void) + { + preempt_disable(); + mdelay(1); + preempt_enable(); + return 0; + + }kernel/trace/Kconfig +9
-0@@ -390,6 +390,34 @@ config OSNOISE_TRACER To enable this tracer, echo in "osnoise" into the current_tracer file. +config TIMERLAT_TRACER + bool "Timerlat tracer" + select OSNOISE_TRACER + select GENERIC_TRACER + help + The timerlat tracer aims to help the preemptive kernel developers + to find sources of wakeup latencies of real-time threads. + + The tracer creates a per-cpu kernel thread with real-time priority.
kernel/trace/Kconfig config OSNOISE_TRACER · line 411
Quoted 10 lines
kernel/trace/Kconfig +10
-0+ The tracer thread sets a periodic timer to wakeup itself, and goes + to sleep waiting for the timer to fire. At the wakeup, the thread + then computes a wakeup latency value as the difference between + the current time and the absolute time that the timer was set + to expire. + + The tracer prints two lines at every activation. The first is the + timer latency observed at the hardirq context before the + activation of the thread. The second is the timer latency observed + by the thread, which is the same level that cyclictest reports. The
Again, change the reference to cyclictest here. As what cyclictest reports is the sum of the two. Saying the "same level that cyclictest reports" is misleading.
Quoted 101 lines
kernel/trace/Kconfig +9
-0+ ACTIVATION ID field serves to relate the irq execution to its + respective thread execution. + + The tracer is build on top of osnoise tracer, and the osnoise: + events can be used to trace the source of interference from NMI, + IRQs and other threads. It also enables the capture of the + stacktrace at the IRQ context, which helps to identify the code + path that can cause thread delay. + config MMIOTRACE bool "Memory mapped IO tracing" depends on HAVE_MMIOTRACE_SUPPORT && PCIkernel/trace/trace.h +2
-0@@ -45,6 +45,7 @@ enum trace_type {TRACE_BPUTS ,TRACE_HWLAT ,TRACE_OSNOISE , +TRACE_TIMERLAT ,TRACE_RAW_DATA , TRACE_FUNC_REPEATS,@@ -448,6 +449,7 @@ extern void __ftrace_bad_type(void); IF_ASSIGN(var, ent, struct bputs_entry, TRACE_BPUTS); \ IF_ASSIGN(var, ent, struct hwlat_entry, TRACE_HWLAT); \ IF_ASSIGN(var, ent, struct osnoise_entry, TRACE_OSNOISE);\ + IF_ASSIGN(var, ent, struct timerlat_entry, TRACE_TIMERLAT);\ IF_ASSIGN(var, ent, struct raw_data_entry, TRACE_RAW_DATA);\ IF_ASSIGN(var, ent, struct trace_mmiotrace_rw, \TRACE_MMIO_RW ); \kernel/trace/trace_entries.h +16
-0@@ -385,3 +385,19 @@ FTRACE_ENTRY(osnoise, osnoise_entry, __entry->softirq_count, __entry->thread_count) ); + +FTRACE_ENTRY (timerlat, timerlat_entry, + +TRACE_TIMERLAT , + +F_STRUCT ( + __field( unsigned int, seqnum ) + __field( int, context ) +__field ( u64, timer_latency ) + ), + +F_printk ("seq:%u\tcontext:%d\ttimer_latency:%llu\n" , + __entry->seqnum, + __entry->context, + __entry->timer_latency) +);kernel/trace/trace_osnoise.c +9
-0@@ -1,6 +1,7 @@// SPDX-License-Identifier: GPL-2.0 /* * OS Noise Tracer: computes the OS Noise suffered by a running thread. +* Timerlat Tracer: measures the wakeup latency of a timer triggered IRQ and thread. * * Based on "hwlat_detector" tracer by: * Copyright (C) 2008-2009 Jon Masters, Red Hat, Inc. <[email protected]> @@ -21,6 +22,7 @@#include <linux/cpumask.h> #include <linux/delay.h> #include <linux/sched/clock.h> +#include <uapi/linux/sched/types.h> #include <linux/sched.h> #include "trace.h" @@ -45,6 +47,9 @@ static struct trace_array *osnoise_trace;#define DEFAULT_SAMPLE_PERIOD 1000000/* 1s */ #define DEFAULT_SAMPLE_RUNTIME 1000000/* 1s */ +#define DEFAULT_TIMERLAT_PERIOD 1000/* 1ms */ +#define DEFAULT_TIMERLAT_PRIO 95/* FIFO 95 */ +/* * NMI runtime info. */ @@ -62,6 +67,8 @@ struct irq {u64 delta_start; }; +#define IRQ_CONTEXT 0 +#define THREAD_CONTEXT 1/* * SofIRQ runtime info. */ @@ -108,32 +115,76 @@ static inline struct osnoise_variables *this_cpu_osn_var(void)return this_cpu_ptr (&per_cpu_osnoise_var); } +#ifdef CONFIG_TIMERLAT_TRACER +/*
kernel/trace/trace_osnoise.c static inline struct osnoise_variables *this_cpu_osn_var(void) · line 129
Quoted 10 lines
kernel/trace/trace_osnoise.c +10
-0+* Runtime information for the timer mode. +*/ +struct timerlat_variables { +struct task_struct *kthread; +struct hrtimer timer; +u64 rel_period; +u64 abs_period; +bool tracing_thread; +u64 count; +};
Like with the osnoise comment, put in tabs to make the fields stand out.
Quoted 68 lines
kernel/trace/trace_osnoise.c +38
-6+ +DEFINE_PER_CPU(struct timerlat_variables, per_cpu_timerlat_var); +/** -* osn_var_reset - Reset the values of the given osnoise_variables +* this_cpu_tmr_var - Return the per-cpu timerlat_variables on its relative CPU +*/ +static inline struct timerlat_variables *this_cpu_tmr_var (void ) +{ +return this_cpu_ptr (&per_cpu_timerlat_var); +} + +/** +* tlat_var_reset - Reset the values of the given timerlat_variables */ -static inline void osn_var_reset (struct osnoise_variables *osn_var) +static inline void tlat_var_reset (void ) { +struct timerlat_variables *tlat_var; +int cpu;/* * So far, all the values are initialized as 0, so * zeroing the structure is perfect. */ -memset (osn_var,0 ,sizeof (struct osnoise_variables )); +for_each_cpu (cpu, cpu_online_mask) { + tlat_var =per_cpu_ptr (&per_cpu_timerlat_var, cpu); +memset (tlat_var,0 ,sizeof (struct timerlat_variables )); + } } +#else /* CONFIG_TIMERLAT_TRACER */ +#define tlat_var_reset () do {} while (0) +#endif /* CONFIG_TIMERLAT_TRACER */ /** -* osn_var_reset_all - Reset the value of all per-cpu osnoise_variables +* osn_var_reset - Reset the values of the given osnoise_variables */ -static inline void osn_var_reset_all (void ) +static inline void osn_var_reset (void ) {struct osnoise_variables *osn_var;int cpu; +/* +* So far, all the values are initialized as 0, so +* zeroing the structure is perfect. +*/ for_each_cpu (cpu, cpu_online_mask) { osn_var =per_cpu_ptr (&per_cpu_osnoise_var, cpu); -osn_var_reset (osn_var); +memset (osn_var,0 ,sizeof (struct osnoise_variables )); } } +/** +* osn_var_reset_all - Reset the value of all per-cpu osnoise_variables +*/ +static inline void osn_var_reset_all (void ) +{ +osn_var_reset (); +tlat_var_reset (); +} +/* * Tells NMIs to call back to the osnoise tracer to record timestamps. */
kernel/trace/trace_osnoise.c struct osnoise_sample { · line 214
Quoted 10 lines
kernel/trace/trace_osnoise.c +7
-0@@ -154,6 +205,18 @@ struct osnoise_sample {int thread_count;/* # Threads during this sample */ }; +#ifdef CONFIG_TIMERLAT_TRACER +/* + * timerlat sample structure definition. Used to store the statistics of + * a sample run. + */ +struct timerlat_sample { + u64 seqnum; /* unique sequence */
The seqnum in the event is unsigned int, whereas here it's u64.
Quoted 79 lines
kernel/trace/trace_osnoise.c +58
-2+u64 timer_latency;/* timer_latency */ + int context; /* timer context */ +}; +#endif +/* * Protect the interface. */ @@ -165,13 +228,23 @@ struct mutex interface_lock;static struct osnoise_data {u64 sample_period;/* total sampling period */ u64 sample_runtime;/* active sampling portion of period */ -u64 stop_tracing_in;/* stop trace in the inside operation (loop) */ -u64 stop_tracing_out;/* stop trace in the outside operation (report) */ +u64 stop_tracing_in;/* stop trace in the inside operation (loop/irq) */ +u64 stop_tracing_out;/* stop trace in the outside operation (report/thread) */ +#ifdef CONFIG_TIMERLAT_TRACER +u64 timerlat_period;/* timerlat period */ +u64 print_stack;/* print IRQ stack if total > */ +int timerlat_tracer;/* timerlat tracer */ +#endif } osnoise_data = { .sample_period =DEFAULT_SAMPLE_PERIOD , .sample_runtime =DEFAULT_SAMPLE_RUNTIME , .stop_tracing_in =0 , .stop_tracing_out =0 , +#ifdef CONFIG_TIMERLAT_TRACER + .print_stack =0 , + .timerlat_period =DEFAULT_TIMERLAT_PERIOD , + .timerlat_tracer =0 , +#endif };/* @@ -232,6 +305,125 @@ static void trace_osnoise_sample(struct osnoise_sample *sample)trace_buffer_unlock_commit_nostack (buffer, event); } +#ifdef CONFIG_TIMERLAT_TRACER +/* +* Print the timerlat header info. +*/ +static void print_timerlat_headers (struct seq_file *s) +{ +seq_puts (s,"# _-----=> irqs-off\n" ); +seq_puts (s,"# / _----=> need-resched\n" ); +seq_puts (s,"# | / _---=> hardirq/softirq\n" ); +seq_puts (s,"# || / _--=> preempt-depth\n" ); +seq_puts (s,"# || /\n" ); +seq_puts (s,"# |||| ACTIVATION\n" ); +seq_puts (s,"# TASK-PID CPU# |||| TIMESTAMP ID " ); +seq_puts (s," CONTEXT LATENCY\n" ); +seq_puts (s,"# | | | |||| | | " ); +seq_puts (s," | |\n" ); +} + +/* +* Record an timerlat_sample into the tracer buffer. +*/ +static void trace_timerlat_sample (struct timerlat_sample *sample) +{ +struct trace_array *tr = osnoise_trace; +struct trace_event_call *call = &event_osnoise; +struct trace_buffer *buffer = tr->array_buffer.buffer; +struct ring_buffer_event *event; +struct timerlat_entry *entry; + + event =trace_buffer_lock_reserve (buffer,TRACE_TIMERLAT ,sizeof (*entry), +tracing_gen_ctx ()); +if (!event) +return ; + entry =ring_buffer_event_data (event); + entry->seqnum = sample->seqnum; + entry->context = sample->context; + entry->timer_latency = sample->timer_latency; + +if (!call_filter_check_discard (call, entry, buffer, event)) +trace_buffer_unlock_commit_nostack (buffer, event); +}
kernel/trace/trace_osnoise.c static void trace_osnoise_sample(struct osnoise_sample *sample) · line 358
Quoted 10 lines
kernel/trace/trace_osnoise.c +10
-0+ +#ifdef CONFIG_STACKTRACE +/* + * Stack trace will take place only at IRQ level, so, no need + * to control nesting here. + */ +struct trace_stack { + int stack_size; + int nr_entries; + unsigned long calls[PAGE_SIZE];
That is rather big. It's 8 * PAGE_SIZE. I don't think that's what you really wanted.
kernel/trace/trace_osnoise.c static void trace_osnoise_sample(struct osnoise_sample *sample) · line 363
Quoted 5 lines
kernel/trace/trace_osnoise.c +5
-0+}; + +static DEFINE_PER_CPU(struct trace_stack, trace_stack); + +/**
Again, remove the KernelDoc notation of /**, or make it real kerneldoc notation.
Quoted 79 lines
kernel/trace/trace_osnoise.c +72
-0+* timerlat_save_stack - save a stack trace without printing +* +* Save the current stack trace without printing. The +* stack will be printed later, after the end of the measurement. +*/ +static void timerlat_save_stack (int skip) +{ +unsigned int size, nr_entries; +struct trace_stack *fstack; + + fstack =this_cpu_ptr (&trace_stack); + + size =ARRAY_SIZE (fstack->calls); + + nr_entries =stack_trace_save (fstack->calls, size, skip); + + fstack->stack_size = nr_entries *sizeof (unsigned long ); + fstack->nr_entries = nr_entries; + +return ; + +} +/** +* timerlat_dump_stack - dump a stack trace previously saved +* +* Dump a saved stack trace into the trace buffer. +*/ +static void timerlat_dump_stack (void ) +{ +struct trace_event_call *call = &event_osnoise; +struct trace_array *tr = osnoise_trace; +struct trace_buffer *buffer = tr->array_buffer.buffer; +struct ring_buffer_event *event; +struct trace_stack *fstack; +struct stack_entry *entry; +unsigned int size; + +preempt_disable_notrace (); + fstack =this_cpu_ptr (&trace_stack); + size = fstack->stack_size; + + event =trace_buffer_lock_reserve (buffer,TRACE_STACK ,sizeof (*entry) + size, +tracing_gen_ctx ()); +if (!event) + goto out; + + entry =ring_buffer_event_data (event); + +memcpy (&entry->caller, fstack->calls, size); + entry->size = fstack->nr_entries; + +if (!call_filter_check_discard (call, entry, buffer, event)) +trace_buffer_unlock_commit_nostack (buffer, event); + +out: +preempt_enable_notrace (); +} +#else +#define timerlat_dump_stack () do {} while (0) +#define timerlat_save_stack (a) do {} while (0) +#endif /* CONFIG_STACKTRACE */ +#endif /* CONFIG_TIMERLAT_TRACER */ +/** * Macros to encapsulate the time capturing infrastructure. */ @@ -373,6 +565,30 @@ set_int_safe_time(struct osnoise_variables *osn_var, u64 *time)return int_counter; } +#ifdef CONFIG_TIMERLAT_TRACER +/** +* copy_int_safe_time - Copy *src into *desc aware of interference +*/ +static u64 +copy_int_safe_time (struct osnoise_variables *osn_var,u64 *dst,u64 *src) +{ +u64 int_counter; +
kernel/trace/trace_osnoise.c set_int_safe_time(struct osnoise_variables *osn_var, u64 *time) · line 586
Quoted 10 lines
kernel/trace/trace_osnoise.c +10
-0+do { + int_counter =local_read (&osn_var->int_counter); +/* synchronize with interrupts */ +barrier (); + + *dst = *src; + +/* synchronize with interrupts */ +barrier (); + }while (int_counter !=local_read (&osn_var->int_counter));
Note, that the loop is unnecessary on 64 bit machines.
The compiler should not split loads, in such cases.
Quoted 11 lines
kernel/trace/trace_osnoise.c +5
-0+ + return int_counter; +} +#endif /* CONFIG_TIMERLAT_TRACER */ +/** * trace_osnoise_callback - NMI entry/exit callback * @@ -801,6 +1017,22 @@ void trace_softirq_exit_callback(void *data, unsigned int vec_nr)if (!osn_var->sampling)return ;
kernel/trace/trace_osnoise.c void trace_softirq_exit_callback(void *data, unsigned int vec_nr) · line 1028
Quoted 10 lines
kernel/trace/trace_osnoise.c +9
-0+#ifdef CONFIG_TIMERLAT_TRACER +/* +* If the timerlat is enabled, but the irq handler did +* not run yet enabling timerlat_tracer, do not trace. +*/ +if (unlikely (osnoise_data.timerlat_tracer)) { +struct timerlat_variables *tlat_var; + tlat_var =this_cpu_tmr_var (); +if (!tlat_var->tracing_thread) {
What happens if the timer interrupt triggers here?
Quoted 11 lines
kernel/trace/trace_osnoise.c +7
-0+ osn_var->softirq.arrival_time =0 ; + osn_var->softirq.delta_start =0 ; + return; + } + } +#endif + duration =get_int_safe_duration (osn_var, &osn_var->softirq.delta_start);trace_softirq_noise (vec_nr, osn_var->softirq.arrival_time, duration);cond_move_thread_delta_start (osn_var, duration);
kernel/trace/trace_osnoise.c thread_exit(struct osnoise_variables *osn_var, struct task_struct *t) · line 1132
Quoted 8 lines
kernel/trace/trace_osnoise.c +5
-0@@ -893,6 +1125,18 @@ thread_exit(struct osnoise_variables *osn_var, struct task_struct *t)if (!osn_var->sampling)return ; +#ifdef CONFIG_TIMERLAT_TRACER +if (osnoise_data.timerlat_tracer) { +struct timerlat_variables *tlat_var; + tlat_var =this_cpu_tmr_var (); +if (!tlat_var->tracing_thread) {
Or here?
Quoted 55 lines
kernel/trace/trace_osnoise.c +48
-0+ osn_var->thread.delta_start =0 ; + osn_var->thread.arrival_time =0 ; + return; + } + } +#endif + duration =get_int_safe_duration (osn_var, &osn_var->thread.delta_start);trace_thread_noise (t, osn_var->thread.arrival_time, duration);@@ -1182,6 +1426,197 @@ static int osnoise_main(void *data)return 0 ; } +#ifdef CONFIG_TIMERLAT_TRACER +/** +* timerlat_irq - hrtimer handler for timerlat. +*/ +static enum hrtimer_restart timerlat_irq (struct hrtimer *timer) +{ +struct osnoise_variables *osn_var =this_cpu_osn_var (); +struct trace_array *tr = osnoise_trace; +struct timerlat_variables *tlat; +struct timerlat_sample s; +u64 now; +u64 diff; + +/* +* I am not sure if the timer was armed for this CPU. So, get +* the timerlat struct from the timer itself, not from this +* CPU. +*/ + tlat = container_of(timer, struct timerlat_variables, timer); + + now =ktime_to_ns (hrtimer_cb_get_time (&tlat->timer)); + +/* +* Enable the osnoise: events for thread an softirq. +*/ + tlat->tracing_thread = true; + + osn_var->thread.arrival_time =time_get (); + +/* +* A hardirq is running: the timer IRQ. It is for sure preempting +* a thread, and potentially preempting a softirq. +* +* At this point, it is not interesting to know the duration of the +* preempted thread (and maybe softirq), but how much time they will +* delay the beginning of the execution of the timer thread. +* +* To get the correct (net) delay added by the softirq, its delta_start +* is set as the IRQ one. In this way, at the return of the IRQ, the delta +* start of the sofitrq will be zeroed, accounting then only the time +* after that.
kernel/trace/trace_osnoise.c static int osnoise_main(void *data) · line 1479
Quoted 10 lines
kernel/trace/trace_osnoise.c +10
-0+* +* The thread follows the same principle. However, if a softirq is +* running, the thread needs to receive the softirq delta_start. The +* reason being is that the softirq will be the last to be unfolded, +* resseting the thread delay to zero. +*/ +#ifndef CONFIG_PREEMPT_RT +if (osn_var->softirq.delta_start) { +copy_int_safe_time (osn_var, &osn_var->thread.delta_start, + &osn_var->softirq.delta_start);
Isn't softirq.delta_start going to be zero here? It doesn't look to get updated until you set tracing_thread to true, but that happens here, and as this is in a interrupt context, there will not be a softirq happening between the setting of that to true to this point.
Quoted 33 lines
kernel/trace/trace_osnoise.c +33
-0+ +copy_int_safe_time (osn_var, &osn_var->softirq.delta_start, + &osn_var->irq.delta_start); + }else { +copy_int_safe_time (osn_var, &osn_var->thread.delta_start, + &osn_var->irq.delta_start); + } +#else /* CONFIG_PREEMPT_RT */ +/* +* The sofirqs run as threads on RT, so there is not need +* to keep track of it. +*/ +copy_int_safe_time (osn_var, &osn_var->thread.delta_start, &osn_var->irq.delta_start); +#endif /* CONFIG_PREEMPT_RT */ + +/* +* Compute the current time with the expected time. +*/ + diff = now - tlat->abs_period; + + tlat->count++; + s.seqnum = tlat->count; + s.timer_latency = diff; + s.context =IRQ_CONTEXT ; + +trace_timerlat_sample (&s); + +/* Keep a running maximum ever recorded os noise "latency" */ +if (diff > tr->max_latency) { + tr->max_latency = diff; +latency_fsnotify (tr); + } +
kernel/trace/trace_osnoise.c static int osnoise_main(void *data) · line 1522
Quoted 10 lines
kernel/trace/trace_osnoise.c +10
-0+if (osnoise_data.stop_tracing_in) +if (time_to_us (diff) >= osnoise_data.stop_tracing_in) +osnoise_stop_tracing (); + +wake_up_process (tlat->kthread); + +#ifdef CONFIG_STACKTRACE +if (osnoise_data.print_stack) +timerlat_save_stack (0 ); +#endif
No need for the #ifdef above. timerlat_save_stack() is defined as a nop when not enabled, and the compiler will just optimize this out.
Quoted 41 lines
kernel/trace/trace_osnoise.c +41
-0+ +return HRTIMER_NORESTART ; +} + +/** +* wait_next_period - Wait for the next period for timerlat +*/ +static int wait_next_period (struct timerlat_variables *tlat) +{ +ktime_t next_abs_period, now; +u64 rel_period = osnoise_data.timerlat_period *1000 ; + + now =hrtimer_cb_get_time (&tlat->timer); + next_abs_period =ns_to_ktime (tlat->abs_period + rel_period); + +/* +* Save the next abs_period. +*/ + tlat->abs_period = (u64 )ktime_to_ns (next_abs_period); + +/* +* If the new abs_period is in the past, skip the activation. +*/ +while (ktime_compare (now, next_abs_period) >0 ) { + next_abs_period =ns_to_ktime (tlat->abs_period + rel_period); + tlat->abs_period = (u64 )ktime_to_ns (next_abs_period); + } + +set_current_state (TASK_INTERRUPTIBLE ); + +hrtimer_start (&tlat->timer, next_abs_period,HRTIMER_MODE_ABS_PINNED_HARD ); +schedule (); +return 1 ; +} + +/** +* timerlat_main- Timerlat main +*/ +static int timerlat_main (void *data) +{ +struct osnoise_variables *osn_var =this_cpu_osn_var ();
kernel/trace/trace_osnoise.c static int osnoise_main(void *data) · line 1573
Quoted 10 lines
kernel/trace/trace_osnoise.c +10
-0+struct timerlat_variables *tlat =this_cpu_tmr_var (); +struct timerlat_sample s; +struct sched_param sp; +u64 now, diff; + +/* +* Make the thread RT, that is how cyclictest is usually used. +*/ + sp.sched_priority =DEFAULT_TIMERLAT_PRIO ; +sched_setscheduler_nocheck (current,SCHED_FIFO , &sp);
Hmm, I thought Peter Zijlstra was removing all sched_setscheduler*() calls in the kernel :-/ Although, this one seems legit, and we are not running from within a module.
-- Steve
Quoted 45 lines
kernel/trace/trace_osnoise.c +45
-0+ + tlat->count =0 ; + tlat->tracing_thread = false; + +hrtimer_init (&tlat->timer,CLOCK_MONOTONIC ,HRTIMER_MODE_ABS_PINNED_HARD ); + tlat->timer.function = timerlat_irq; + tlat->kthread = current; + osn_var->pid = current->pid; +/* +* Anotate the arrival time. +*/ + tlat->abs_period =hrtimer_cb_get_time (&tlat->timer); + +wait_next_period (tlat); + + osn_var->sampling =1 ; + +while (!kthread_should_stop ()) { + now =ktime_to_ns (hrtimer_cb_get_time (&tlat->timer)); + diff = now - tlat->abs_period; + + s.seqnum = tlat->count; + s.timer_latency = diff; + s.context =THREAD_CONTEXT ; + +trace_timerlat_sample (&s); + +#ifdef CONFIG_STACKTRACE +if (osnoise_data.print_stack) +if (osnoise_data.print_stack <=time_to_us (diff)) +timerlat_dump_stack (); +#endif /* CONFIG_STACKTRACE */ + + tlat->tracing_thread = false; +if (osnoise_data.stop_tracing_out) +if (time_to_us (diff) >= osnoise_data.stop_tracing_out) +osnoise_stop_tracing (); + +wait_next_period (tlat); + } + +hrtimer_cancel (&tlat->timer); + return 0; +} +#endif /* CONFIG_TIMERLAT_TRACER */
Re: [PATCH V3 9/9] tracing: Add timerlat tracer
Quoted 2 lines · Steven Rostedt
On Fri, 14 May 2021 22:51:18 +0200
Daniel Bristot de Oliveira <[email protected]> wrote:
[...]
Quoted 31 lines
Quoted 1 line
It is possible to follow the trace by reading the trace trace file::
Do not need rst markup in commit logs ;-)
Quoted 21 lines
[root@f32 tracing]# cat trace
# tracer: timerlat
#
# _-----=> irqs-off
# / _----=> need-resched# | / _---=> hardirq/softirq # || / _--=> preempt-depth # || / # |||| ACTIVATION # TASK-PID CPU# |||| TIMESTAMP ID CONTEXT LATENCY # | | | |||| | | | | <idle>-0 [000] d.h1 54.029328: #1 context irq timer_latency 932 ns <...>-867 [000] .... 54.029339: #1 context thread timer_latency 11700 ns <idle>-0 [001] dNh1 54.029346: #1 context irq timer_latency 2833 ns <...>-868 [001] .... 54.029353: #1 context thread timer_latency 9820 ns <idle>-0 [000] d.h1 54.030328: #2 context irq timer_latency 769 ns <...>-867 [000] .... 54.030330: #2 context thread timer_latency 3070 ns <idle>-0 [001] d.h1 54.030344: #2 context irq timer_latency 935 ns <...>-868 [001] .... 54.030347: #2 context thread timer_latency 4351 nsQuoted 5 lines
The tracer creates a per-cpu kernel thread with real-time priority that prints two lines at every activation. The first is the *timer latency* observed at the *hardirq* context before the activation of the thread. The second is the *timer latency* observed by the thread, which is the same level that cyclictest reports. The ACTIVATION ID field
Quoted 4 lines
The above is misleading. Below, I see that you state that the values are "net values" where the thread latency does not include the irq latency. This is not the same as cyclictest. (I had to update my ASCII art below after reading the below statement).
Replying here all the comments about the timerlat/cyclictest timeline, and gross/net values.
So, yeah, my description was not clear enough. The values that are net are those reported by the *osnoise: events* only. The *timerlat tracer* values are not discounted, and that is why they are similar to the value reported by cyclictest (ok, cyclictest still captures the exit to user overhead and friends).
Quoted 17 lines
Quoted 10 lines
serves to relate the *irq* execution to its respective *thread* execution.
The irq/thread splitting is important to clarify at which context the unexpected high value is coming from. The *irq* context can be delayed by hardware related actions, such as SMIs, NMIs, IRQs or by a thread masking interrupts. Once the timer happens, the delay can also be influenced by blocking caused by threads. For example, by postponing the scheduler execution via
preempt_disable(), by the scheduler execution, or by masking interrupts. Threads can also be delayed by the interference from other threads and IRQs.I wonder if ASCII art would help clarify the above. At least for the document (not the change log here).
time ==>
Quoted 15 lines
expected actual thread
wakeup wakeup scheduled
| | |
v v v
|---------|-------|------|----------|
^
|
interrupt
|--------------|
irq latency
|-----------|
thread latencyA liked the idea of adding a timeline!
[...]
Quoted 30 lines
Quoted 30 lines
Documentation/trace/timerlat-tracer.rst new file +30
-0+ [root@f32 tracing]# cat trace + # tracer: timerlat + # + # _-----=> irqs-off + # / _----=> need-resched + # | / _---=> hardirq/softirq + # || / _--=> preempt-depth + # || / + # |||| ACTIVATION + # TASK-PID CPU# |||| TIMESTAMP ID CONTEXT LATENCY + # | | | |||| | | | | + <idle>-0 [000] d.h1 54.029328: #1 context irq timer_latency 932 ns + <...>-867 [000] .... 54.029339: #1 context thread timer_latency 11700 ns + <idle>-0 [001] dNh1 54.029346: #1 context irq timer_latency 2833 ns + <...>-868 [001] .... 54.029353: #1 context thread timer_latency 9820 ns + <idle>-0 [000] d.h1 54.030328: #2 context irq timer_latency 769 ns + <...>-867 [000] .... 54.030330: #2 context thread timer_latency 3070 ns + <idle>-0 [001] d.h1 54.030344: #2 context irq timer_latency 935 ns + <...>-868 [001] .... 54.030347: #2 context thread timer_latency 4351 ns + + +The tracer creates a per-cpu kernel thread with real-time priority that +prints two lines at every activation. The first is the *timer latency* +observed at the *hardirq* context before the activation of the thread. +The second is the *timer latency* observed by the thread, which is the +same level that cyclictest reports. The ACTIVATION ID field +serves to relate the *irq* execution to its respective *thread* execution. + +The *irq*/*thread* splitting is important to clarify at which context +the unexpected high value is coming from. The *irq* context can be
Quoted 8 lines
Documentation/trace/timerlat-tracer.rst line 60
Quoted 6 lines
Documentation/trace/timerlat-tracer.rst new file +6
-0+delayed by hardware related actions, such as SMIs, NMIs, IRQs +or by a thread masking interrupts. Once the timer happens, the delay +can also be influenced by blocking caused by threads. For example, by +postponing the scheduler execution via preempt_disable(), by the +scheduler execution, or by masking interrupts. Threads can +also be delayed by the interference from other threads and IRQs.This is where I would add that ASCII art.
I am proposing a ASCII art on another point.... see bellow.
Quoted 61 lines
Quoted 9 lines
Documentation/trace/timerlat-tracer.rst new file +8
-0+ +Tracer options +--------------------- + +The timerlat tracer is built on top of osnoise tracer. +So its configuration is also done in the osnoise/ config +directory. The timerlat configs are: +Documentation/trace/timerlat-tracer.rst line 78
Quoted 10 lines
Documentation/trace/timerlat-tracer.rst new file +10
-0+ - cpus: CPUs at which a timerlat thread will execute. + - timerlat_period_us: the period of the timerlat thread. + - osnoise/stop_tracing_in_us: stop the system tracing if a + timer latency at the *irq* context higher than the configured + value happens. Writing 0 disables this option. + - stop_tracing_out_us: stop the system tracing if a + timer latency at the *thread* context higher than the configured + value happens. Writing 0 disables this option. + - print_stack: save the stack of the IRQ ocurrence, and print + it after the *thread* read the latency."thread read the latency" doesn't make sense.
"and print it after the *thread context* event". ?
Documentation/trace/timerlat-tracer.rst line 88
Quoted 10 lines
Documentation/trace/timerlat-tracer.rst new file +10
-0+ +timerlat and osnoise +---------------------------- + +The timerlat can also take advantage of the osnoise: traceevents. +For example:: + + [root@f32 ~]# cd /sys/kernel/tracing/ + [root@f32 tracing]# echo timerlat > current_tracer + [root@f32 tracing]# echo osnoise > set_eventNote,
set_eventshould be deprecated. Use:echo 1 > events/osnoise/enable
instead.
Quoted 5 lines
Documentation/trace/timerlat-tracer.rst new file +5
-0+ [root@f32 tracing]# echo 25 > osnoise/stop_tracing_out_us + [root@f32 tracing]# tail -10 trace + cc1-87882 [005] d..h... 548.771078: #402268 context irq timer_latency 1585 ns + cc1-87882 [005] dNLh1.. 548.771082: irq_noise: local_timer:236 start 548.771077442 duration 4597 ns + cc1-87882 [005] dNLh2.. 548.771083: irq_noise: reschedule:253 start 548.771083017 duration 56 nsDocumentation/trace/timerlat-tracer.rst line 103
Quoted 10 lines
Documentation/trace/timerlat-tracer.rst new file +10
-0+ cc1-87882 [005] dNLh2.. 548.771086: irq_noise: call_function_single:251 start 548.771083811 duration 2048 ns + cc1-87882 [005] dNLh2.. 548.771088: irq_noise: call_function_single:251 start 548.771086814 duration 1495 ns + cc1-87882 [005] dNLh2.. 548.771091: irq_noise: call_function_single:251 start 548.771089194 duration 1558 ns + cc1-87882 [005] dNLh2.. 548.771094: irq_noise: call_function_single:251 start 548.771091719 duration 1932 ns + cc1-87882 [005] dNLh2.. 548.771096: irq_noise: call_function_single:251 start 548.771094696 duration 1050 ns + cc1-87882 [005] d...3.. 548.771101: thread_noise: cc1:87882 start 548.771078243 duration 10909 ns + timerlat/5-1035 [005] ....... 548.771103: #402268 context thread timer_latency 25960 ns + +In this case, the root cause of the timer latency does not point for a +single, but to a series of call_function_single IPIs, followed by a 10"not point to a single"
Quoted 9 lines
Documentation/trace/timerlat-tracer.rst line 108
Quoted 5 lines
Documentation/trace/timerlat-tracer.rst new file +5
-0+*us* delay from a cc1 thread noise, along with the regular timer +activation. It is worth mentioning that the *duration* values reported +by the osnoise events are *net* values. For example, the +thread_noise does not include the duration of the overhead caused +by the IRQ execution (which indeed accounted for 12736 ns).As stated above, I updated my view of the ASCII art after reading this. You should not compare what cyclictest reports as the thread latency. But what cyclictest reports is the sum of the two (irq latency plus thread latency).
Here is the point where I mention net values... so I am changing this part of documentation to:
------------------- %< -----------------------------
It is worth mentioning that the *duration* values reported by the osnoise: events are *net* values. For example, the thread_noise does not include the duration of the overhead caused by the IRQ execution (which indeed accounted for 12736 ns). But the values reported by the timerlat tracer (timerlat_latency) are *gross* values.
The art below illustrates a CPU timeline and how the timerlat tracer observes it at the top and the osnoise: events at the bottom. Each "-" in the timelines means 1 us, and the time moves ==>:
External context irq context thread
clock timer_latency timer_latency
event 18 us 48 us
| ^ ^
v | |
|------------------| | <-- timerlat irq timeline
|------------------+-----------------------------| <-- timerlat thread timeline
^ ^
===================== CPU timeline ======================================
[timerlat/ irq] [ dev irq ]
[another thread...^ v..^ v........][timerlat/ thread]
===================== CPU timeline ======================================
|-------------| |---------| <-- irq_noise timeline
|--^ v--------| <-- thread_noise timeline
| | |
| | + thread_noise: 10 us
| +-> irq_noise: 9 us
+-> irq_noise: 13 us--------------- >% --------------------------------
thoughts?
-- Daniel
Steven Rostedt
maintainerRe: [PATCH V3 9/9] tracing: Add timerlat tracer
Quoted 24 lines · On Fri, 11 Jun 2021 14:59:13 +0200 Daniel Bristot de Oliveira…
------------------ %< -----------------------------
It is worth mentioning that the *duration* values reported by the osnoise: events are *net* values. For example, thethread_noisedoes not include the duration of the overhead caused by the IRQ execution (which indeed accounted for 12736 ns). But the values reported by the timerlat tracer (timerlat_latency) are *gross* values.The art below illustrates a CPU timeline and how the timerlat tracer observes it at the top and the osnoise: events at the bottom. Each "-" in the timelines means 1 us, and the time moves ==>:
External context irq context thread
clocktimer_latencytimer_latency
event 18 us 48 us
| ^ ^
v | |
|------------------| | <-- timerlat irq timeline
|------------------+-----------------------------| <-- timerlat thread timeline
^ ^
===================== CPU timeline ======================================
[timerlat/ irq] [ dev irq ]
[another thread...^ v..^ v........][timerlat/ thread]
===================== CPU timeline ======================================
Quoted 8 lines
|-------------| |---------| <-- irq_noise timeline |--^ v--------| <-- thread_noise timeline | | | | | + thread_noise: 10 us | +-> irq_noise: 9 us +-> irq_noise: 13 us--------------- >% --------------------------------
That's really busy, and honestly, I can't tell what is what.
The "context irq timer_latency" is a confusing name. Could we just have that be "timer irq latency"? And "context thread timer_latency" just be "thread latency". Adding too much text to the name actually makes it harder to understand. We want to simplify it, not make people have to think harder to see it.
I think we can get rid of the "<-- .* timeline" to the right. I don't think they are necessary. Again, the more you add to the diagram, the busier it looks, and the harder it is to read.
Could we switch "[timerlat/ irq]" to just "[timer irq]" and explain how that "context irq timer_latency"/"timer irq latency" is related?
Should probably state that the "dev irq" is an unrelated device interrupt that happened.
What's with the two CPU timeline lines? Now there I think it would be better to have the arrow text by itself.
And finally, not sure if you plan on doing this, but have a output of the trace that would show the above.
Thus, here's what I would expect to see:
External
clock timer irq latency thread latency
event 18 us 48 us
| ^ ^
v | |
|------------------| |
|------------------+-----------------------------|
^ ^
=========================================================================
[timerlat/ irq] [ dev irq ]
[another thread...^ v..^ v........][timerlat/ thread] <-- CPU task timeline
=========================================================================
|-------------| |---------|
|--^ v--------|
| | |
| | + thread_noise: 10 us
| +-> irq_noise: 9 us
+-> irq_noise: 13 usThe "[ dev irq ]" above is an interrupt from some device on the system that causes extra noise to the timerlat task.
I think the above may be easier to understand, especially if the trace output that represents it is below.
Also, I have to ask, shouldn't the "thread noise" really start at the "External clock event"?
-- Steve
Re: [PATCH V3 9/9] tracing: Add timerlat tracer
Quoted 74 lines · Steven Rostedt
Quoted 24 lines · On Fri, 11 Jun 2021 14:59:13 +0200 Daniel Bristot de Oliveira…
------------------ %< -----------------------------
It is worth mentioning that the *duration* values reported by the osnoise: events are *net* values. For example, thethread_noisedoes not include the duration of the overhead caused by the IRQ execution (which indeed accounted for 12736 ns). But the values reported by the timerlat tracer (timerlat_latency) are *gross* values.The art below illustrates a CPU timeline and how the timerlat tracer observes it at the top and the osnoise: events at the bottom. Each "-" in the timelines means 1 us, and the time moves ==>:
External context irq context thread
clocktimer_latencytimer_latency
event 18 us 48 us
| ^ ^
v | |
|------------------| | <-- timerlat irq timeline
|------------------+-----------------------------| <-- timerlat thread timeline
^ ^
===================== CPU timeline ======================================
[timerlat/ irq] [ dev irq ]
[another thread...^ v..^ v........][timerlat/ thread]
===================== CPU timeline ======================================Quoted 8 lines
|-------------| |---------| <-- irq_noise timeline |--^ v--------| <-- thread_noise timeline | | | | | + thread_noise: 10 us | +-> irq_noise: 9 us +-> irq_noise: 13 us--------------- >% --------------------------------
That's really busy, and honestly, I can't tell what is what.
The "context irq
timer_latency" is a confusing name. Could we just have that be "timer irq latency"? And "context threadtimer_latency" just be "thread latency". Adding too much text to the name actually makes it harder to understand. We want to simplify it, not make people have to think harder to see it.I think we can get rid of the "<-- .* timeline" to the right. I don't think they are necessary. Again, the more you add to the diagram, the busier it looks, and the harder it is to read.
Could we switch "[timerlat/ irq]" to just "[timer irq]" and explain how that "context irq timer_latency"/"timer irq latency" is related?
Should probably state that the "dev irq" is an unrelated device interrupt that happened.
What's with the two CPU timeline lines? Now there I think it would be better to have the arrow text by itself.
And finally, not sure if you plan on doing this, but have a output of the trace that would show the above.
Thus, here's what I would expect to see:
External
clock timer irq latency e thread latency
event 18 us 48 us
| ^ ^
v | |
|------------------| |
|------------------+-----------------------------|
^ ^
=========================================================================
[timerlat/ irq] [ dev irq ]
[another thread...^ v..^ v........][timerlat/ thread] <-- CPU task timeline
=========================================================================
Quoted 6 lines
|-------------| |---------|
|--^ v--------|
| | |
| | + thread_noise: 10 us
| +-> irq_noise: 9 us
+-> irq_noise: 13 usIt looks good to me!
Quoted 5 lines
The "[ dev irq ]" above is an interrupt from some device on the system that causes extra noise to the timerlat task.
I think the above may be easier to understand, especially if the trace output that represents it is below.
ok, I can try to capture a trace sample and represent it into the ASCII art format above.
Quoted 2 lines
Also, I have to ask, shouldn't the "thread noise" really start at the "External clock event"?
To go in that direction, we need to track things that delayed the IRQ execution. We are already tracking other IRQs' execution, but we will have to keep a history of past executions and "playback" them. This will add some overhead linear to the past event... and/or some pessimism.
We will also have to track IRQ disabled sections. The problem of tracking IRQ disabled is that it depends on tracing infra-structure that is not enabled by default of distros... And there are IRQ delay causes that are not related to the thread... like idle states... (and all these things create more and more states to track these things)...
So, I added the timer irq latency to figure out when the problem is related to things that delay the IRQ, and the stack trace will help us figure out where the problem is in the thread context. After the IRQ execution, the thread noise is helpful - even without all the thread noise before the IRQ.
Furthermore, if we start trying to abstract the causes of delay, we will find the rtsl :-). The rtls events and abstractions give us the worst-case scheduling latency without adding unneeded pessimism (sound analysis). It covers all the possible cases, for all any schedulers, even without the need of a measuring thread like here (or with cyclictest) - and this is a good thing because it does not change the target system's workload.
The problem is that... rtsl depends on tracing infra-structure that are not enabled by default on distros, like preempt_ and irq_ disabled events.
So, I see timerlat as a tool for on-the-fly usage, like debugging on customers (as we do at red hat). It can be enabled by default on distros because it only depends on existing and already enabled events and causes no overhead when disabled. rtsl targets more specific cases, like safety-critical systems, where the overhead is acceptable because of the sound analysis of the scheduling bound (which is rooted in a formal specification & analysis of the system).
-- Daniel
Quoted 2 lines
-- Steve
Steven Rostedt
maintainerRe: [PATCH V3 9/9] tracing: Add timerlat tracer
Quoted 5 lines · On Sat, 12 Jun 2021 11:41:41 +0200 Daniel Bristot de Oliveira…
Quoted 2 lines
I think the above may be easier to understand, especially if the trace output that represents it is below.
ok, I can try to capture a trace sample and represent it into the ASCII art format above.
Why capture it? Just fudge an example that fits the example ;-)
Quoted 5 lines
Quoted 3 lines
Also, I have to ask, shouldn't the "thread noise" really start at the "External clock event"?
To go in that direction, we need to track things that delayed the IRQ execution.
[snip long explanation of the obvious (to me at least) ;-) ]
Quoted 2 lines
the overhead is acceptable because of the sound analysis of the scheduling bound (which is rooted in a formal specification & analysis of the system).
I meant, that it needs to be documented, what the real thread noise is but due to what is available it may not be truly accurate.
-- Steve
Re: [PATCH V3 9/9] tracing: Add timerlat tracer
In reply to Steven RostedtQuoted 11 lines · Steven Rostedt
Quoted 7 lines · On Fri, 14 May 2021 22:51:18 +0200 Daniel Bristot de Oliveira…
The timerlat tracer aims to help the preemptive kernel developers to found souces of wakeup latencies of real-time threads. Like cyclictest, the tracer sets a periodic timer that wakes up a thread. The thread then computes a *wakeup latency* value as the difference between the *current time* and the *absolute time* that the timer was set to expire. The main goal of timerlat is tracing in such a way to help kernel developers.
Quoted 4 lines
Hmm, we should add a way to have wake up tracers only trace a specific task, where these osnoise trace events would also be useful. That is, run cyclictest with the wakeup tracer, that it does this for cyclictest directly. That shouldn't be too difficult to add.
Yep! the osnoise: events are useful for other tracers, and even alone... Indeed, they are part of the rtsl (which I plan to submit later this year).
It was already on my todo list to find a way to enable the events independently. It could be as simple as adding a "hook" file to the osnoise/ dir, or to hook the events when the first osnoise: event gets enabled, and to unhook them when the last gets disable.
I will have a look at enabling them with wakeup tracers along the way.
Quoted 5 lines
Quoted 5 lines
Usage
Write the ASCII text "timerlat" into the
current_tracerfile of the tracing system (generally mounted at/sys/kernel/tracing).
Quoted 8 lines
Quoted 6 lines
For example:
[root@f32 ~]# cd
/sys/kernel/tracing/[root@f32 tracing]# echo timerlat >current_tracerIt is possible to follow the trace by reading the trace trace file::
Do not need rst markup in commit logs ;-)
Oops! :-)
Quoted 26 lines
Quoted 26 lines
[root@f32 tracing]# cat trace
# tracer: timerlat
#
# _-----=> irqs-off
# / _----=> need-resched# | / _---=> hardirq/softirq # || / _--=> preempt-depth # || / # |||| ACTIVATION # TASK-PID CPU# |||| TIMESTAMP ID CONTEXT LATENCY # | | | |||| | | | | <idle>-0 [000] d.h1 54.029328: #1 context irq timer_latency 932 ns <...>-867 [000] .... 54.029339: #1 context thread timer_latency 11700 ns <idle>-0 [001] dNh1 54.029346: #1 context irq timer_latency 2833 ns <...>-868 [001] .... 54.029353: #1 context thread timer_latency 9820 ns <idle>-0 [000] d.h1 54.030328: #2 context irq timer_latency 769 ns <...>-867 [000] .... 54.030330: #2 context thread timer_latency 3070 ns <idle>-0 [001] d.h1 54.030344: #2 context irq timer_latency 935 ns <...>-868 [001] .... 54.030347: #2 context thread timer_latency 4351 nsThe tracer creates a per-cpu kernel thread with real-time priority that prints two lines at every activation. The first is the *timer latency* observed at the *hardirq* context before the activation of the thread. The second is the *timer latency* observed by the thread, which is the same level that cyclictest reports. The ACTIVATION ID field
[..]
Quoted 11 lines
Documentation/trace/timerlat-tracer.rst line 6
Quoted 9 lines
Documentation/trace/timerlat-tracer.rst new file +6
-0@@ -0,0 +1,158 @@ +############### +Timerlat tracer +############### + +The timerlat tracer aims to help the preemptive kernel developers to +found souces of wakeup latencies of real-time threads. Like cyclictest,"to find sources"
Fixed.
[...]
Quoted 21 lines
Quoted 8 lines
Documentation/trace/timerlat-tracer.rst new file +8
-0+ +Tracer options +--------------------- + +The timerlat tracer is built on top of osnoise tracer. +So its configuration is also done in the osnoise/ config +directory. The timerlat configs are: +Documentation/trace/timerlat-tracer.rst line 78
Quoted 10 lines
Documentation/trace/timerlat-tracer.rst new file +10
-0+ - cpus: CPUs at which a timerlat thread will execute. + - timerlat_period_us: the period of the timerlat thread. + - osnoise/stop_tracing_in_us: stop the system tracing if a + timer latency at the *irq* context higher than the configured + value happens. Writing 0 disables this option. + - stop_tracing_out_us: stop the system tracing if a + timer latency at the *thread* context higher than the configured + value happens. Writing 0 disables this option. + - print_stack: save the stack of the IRQ ocurrence, and print + it after the *thread* read the latency."thread read the latency" doesn't make sense.
Quoted 1 line
"and print it after the *thread context* event". ?
Fixed.
Quoted 14 lines
Documentation/trace/timerlat-tracer.rst line 88
Quoted 11 lines
Documentation/trace/timerlat-tracer.rst new file +10
-0+ +timerlat and osnoise +---------------------------- + +The timerlat can also take advantage of the osnoise: traceevents. +For example:: + + [root@f32 ~]# cd /sys/kernel/tracing/ + [root@f32 tracing]# echo timerlat > current_tracer + [root@f32 tracing]# echo osnoise > set_eventNote,
set_eventshould be deprecated. Use:
Quoted 4 lines
echo 1 > events/osnoise/enable
instead.
Fixed (and mental note added).
Quoted 9 lines
Quoted 9 lines
Documentation/trace/timerlat-tracer.rst new file +9
-0+ [root@f32 tracing]# echo 25 > osnoise/stop_tracing_out_us + [root@f32 tracing]# tail -10 trace + cc1-87882 [005] d..h... 548.771078: #402268 context irq timer_latency 1585 ns + cc1-87882 [005] dNLh1.. 548.771082: irq_noise: local_timer:236 start 548.771077442 duration 4597 ns + cc1-87882 [005] dNLh2.. 548.771083: irq_noise: reschedule:253 start 548.771083017 duration 56 ns + cc1-87882 [005] dNLh2.. 548.771086: irq_noise: call_function_single:251 start 548.771083811 duration 2048 ns + cc1-87882 [005] dNLh2.. 548.771088: irq_noise: call_function_single:251 start 548.771086814 duration 1495 ns + cc1-87882 [005] dNLh2.. 548.771091: irq_noise: call_function_single:251 start 548.771089194 duration 1558 ns + cc1-87882 [005] dNLh2.. 548.771094: irq_noise: call_function_single:251 start 548.771091719 duration 1932 ns
Quoted 8 lines
Documentation/trace/timerlat-tracer.rst line 103
Quoted 6 lines
Documentation/trace/timerlat-tracer.rst new file +6
-0+ cc1-87882 [005] dNLh2.. 548.771096: irq_noise: call_function_single:251 start 548.771094696 duration 1050 ns + cc1-87882 [005] d...3.. 548.771101: thread_noise: cc1:87882 start 548.771078243 duration 10909 ns + timerlat/5-1035 [005] ....... 548.771103: #402268 context thread timer_latency 25960 ns + +In this case, the root cause of the timer latency does not point for a +single, but to a series of call_function_single IPIs, followed by a 10"not point to a single"
Fixed.
[...]
Quoted 32 lines
Quoted 32 lines
Documentation/trace/timerlat-tracer.rst new file +32
-0+IRQ stacktrace +--------------------------- + +The osnoise/print_stack option is helpful for the cases in which a thread +noise causes the major factor for the timer latency, because of preempt or +irq disabled. For example:: + + [root@f32 tracing]# echo 500 > osnoise/stop_tracing_out_us + [root@f32 tracing]# echo 500 > osnoise/print_stack + [root@f32 tracing]# echo timerlat > current_tracer + [root@f32 tracing]# tail -21 per_cpu/cpu7/trace + insmod-1026 [007] dN.h1.. 200.201948: irq_noise: local_timer:236 start 200.201939376 duration 7872 ns + insmod-1026 [007] d..h1.. 200.202587: #29800 context irq timer_latency 1616 ns + insmod-1026 [007] dN.h2.. 200.202598: irq_noise: local_timer:236 start 200.202586162 duration 11855 ns + insmod-1026 [007] dN.h3.. 200.202947: irq_noise: local_timer:236 start 200.202939174 duration 7318 ns + insmod-1026 [007] d...3.. 200.203444: thread_noise: insmod:1026 start 200.202586933 duration 838681 ns + timerlat/7-1001 [007] ....... 200.203445: #29800 context thread timer_latency 859978 ns + timerlat/7-1001 [007] ....1.. 200.203446: <stack trace> + => timerlat_irq + => __hrtimer_run_queues + => hrtimer_interrupt + => __sysvec_apic_timer_interrupt + => asm_call_irq_on_stack + => sysvec_apic_timer_interrupt + => asm_sysvec_apic_timer_interrupt + => delay_tsc + => dummy_load_1ms_pd_init + => do_one_initcall + => do_init_module + => __do_sys_finit_module + => do_syscall_64 + => entry_SYSCALL_64_after_hwframe
Quoted 8 lines
Documentation/trace/timerlat-tracer.rst line 149
Quoted 5 lines
Documentation/trace/timerlat-tracer.rst new file +5
-0+ +In this case, it is possible to see that the thread added the highest +contribution to the *timer latency* and the stack trace points to +a function named dummy_load_1ms_pd_init, which had the following +code (on purpose)::Should add here as well that the stack is saved at the time of interrupt, and not at the time it is reported.
Fixed.
[...]
Quoted 15 lines
Documentation/trace/timerlat-tracer.rst line 98
Quoted 13 lines
Documentation/trace/timerlat-tracer.rst new file +12
-0+#ifdef CONFIG_TIMERLAT_TRACER +/* + * Runtime information for the timer mode. + */ +struct timerlat_variables { + struct task_struct *kthread; + struct hrtimer timer; + u64 rel_period; + u64 abs_period; + bool tracing_thread; + u64 count; +};Like with the osnoise comment, put in tabs to make the fields stand out.
Done.
[...]
Quoted 9 lines
Documentation/trace/timerlat-tracer.rst line 105
Quoted 7 lines
Documentation/trace/timerlat-tracer.rst new file +7
-0+#ifdef CONFIG_TIMERLAT_TRACER +/* + * timerlat sample structure definition. Used to store the statistics of + * a sample run. + */ +struct timerlat_sample { + u64 seqnum; /* unique sequence */The seqnum in the event is unsigned int, whereas here it's u64.
all set to unsigned int.
[...]
Quoted 5 lines
Quoted 5 lines
Documentation/trace/timerlat-tracer.rst new file +5
-0+ +#ifdef CONFIG_STACKTRACE +/* + * Stack trace will take place only at IRQ level, so, no need + * to control nesting here.
Quoted 8 lines
Documentation/trace/timerlat-tracer.rst line 115
Quoted 5 lines
Documentation/trace/timerlat-tracer.rst new file +5
-0+ */ +struct trace_stack { + int stack_size; + int nr_entries; + unsigned long calls[PAGE_SIZE];That is rather big. It's 8 *
PAGE_SIZE. I don't think that's what you really wanted.
no, I did not want that... is 256 a good number?
Quoted 8 lines
Documentation/trace/timerlat-tracer.rst line 120
Quoted 5 lines
Documentation/trace/timerlat-tracer.rst new file +5
-0+}; + +static DEFINE_PER_CPU(struct trace_stack, trace_stack); + +/**Again, remove the KernelDoc notation of /**, or make it real kerneldoc notation.
Fixed!
[...]
Quoted 5 lines
Quoted 5 lines
Documentation/trace/timerlat-tracer.rst new file +0
-0*@@ -801,6 +1017,22 @@ void trace_softirq_exit_callback(void *data, unsigned int vec_nr) if (!osn_var->sampling) return;
Quoted 11 lines
Documentation/trace/timerlat-tracer.rst void trace_softirq_exit_callback(void *data, unsigned int vec_nr) · line 1028
Quoted 9 lines
Documentation/trace/timerlat-tracer.rst new file +9
-0+#ifdef CONFIG_TIMERLAT_TRACER + /* + * If the timerlat is enabled, but the irq handler did + * not run yet enabling timerlat_tracer, do not trace. + */ + if (unlikely(osnoise_data.timerlat_tracer)) { + struct timerlat_variables *tlat_var; + tlat_var = this_cpu_tmr_var(); + if (!tlat_var->tracing_thread) {What happens if the timer interrupt triggers here?
The tracer will not report the softirq overhead. But at this point, the softirq is returning, and the duration would be from this time to...
Quoted 8 lines
Documentation/trace/timerlat-tracer.rst void trace_softirq_exit_callback(void *data, unsigned int vec_nr) · line 1036
Quoted 8 lines
Documentation/trace/timerlat-tracer.rst new file +7
-0+ osn_var->softirq.arrival_time = 0; + osn_var->softirq.delta_start = 0; + return; + } + } +#endif + duration = get_int_safe_duration(osn_var, &osn_var->softirq.delta_start);
here.
We can disable interrupts to avoid this issue. But the question is, is it worth to disable interrupts to avoid this problem?
Quoted 6 lines
Quoted 6 lines
Documentation/trace/timerlat-tracer.rst new file +0
-0trace_softirq_noise(vec_nr, osn_var->softirq.arrival_time, duration); cond_move_thread_delta_start(osn_var, duration);@@ -893,6 +1125,18 @@ thread_exit(struct osnoise_variables *osn_var, struct task_struct *t) if (!osn_var->sampling) return;
Quoted 7 lines
Documentation/trace/timerlat-tracer.rst thread_exit(struct osnoise_variables *osn_var, struct task_struct *t) · line 1132
Quoted 5 lines
Documentation/trace/timerlat-tracer.rst new file +5
-0+#ifdef CONFIG_TIMERLAT_TRACER + if (osnoise_data.timerlat_tracer) { + struct timerlat_variables *tlat_var; + tlat_var = this_cpu_tmr_var(); + if (!tlat_var->tracing_thread) {Or here?
The problem that can happen with the softirq cannot happen here: this code runs with interrupts disabled on __schedule() (it is hooked to the sched_switch).
Quoted 62 lines
Quoted 62 lines
Documentation/trace/timerlat-tracer.rst new file +55
-0+ osn_var->thread.delta_start = 0; + osn_var->thread.arrival_time = 0; + return; + } + } +#endif + duration = get_int_safe_duration(osn_var, &osn_var->thread.delta_start); trace_thread_noise(t, osn_var->thread.arrival_time, duration);@@ -1182,6 +1426,197 @@ static int osnoise_main(void *data) return 0; } +#ifdef CONFIG_TIMERLAT_TRACER +/** + * timerlat_irq - hrtimer handler for timerlat. + */ +static enum hrtimer_restart timerlat_irq(struct hrtimer *timer) +{ + struct osnoise_variables *osn_var = this_cpu_osn_var(); + struct trace_array *tr = osnoise_trace; + struct timerlat_variables *tlat; + struct timerlat_sample s; + u64 now; + u64 diff; + + /* + * I am not sure if the timer was armed for this CPU. So, get + * the timerlat struct from the timer itself, not from this + * CPU. + */ + tlat = container_of(timer, struct timerlat_variables, timer); + + now = ktime_to_ns(hrtimer_cb_get_time(&tlat->timer)); + + /* + * Enable the osnoise: events for thread an softirq. + */ + tlat->tracing_thread = true; + + osn_var->thread.arrival_time = time_get(); + + /* + * A hardirq is running: the timer IRQ. It is for sure preempting + * a thread, and potentially preempting a softirq. + * + * At this point, it is not interesting to know the duration of the + * preempted thread (and maybe softirq), but how much time they will + * delay the beginning of the execution of the timer thread. + * + * To get the correct (net) delay added by the softirq, its delta_start + * is set as the IRQ one. In this way, at the return of the IRQ, the delta + * start of the sofitrq will be zeroed, accounting then only the time + * after that. + * + * The thread follows the same principle. However, if a softirq is + * running, the thread needs to receive the softirq delta_start. The + * reason being is that the softirq will be the last to be unfolded, + * resseting the thread delay to zero. + */ +#ifndef CONFIG_PREEMPT_RT
Quoted 8 lines
Documentation/trace/timerlat-tracer.rst static int osnoise_main(void *data) · line 1479
Quoted 3 lines
Documentation/trace/timerlat-tracer.rst new file +3
-0+ if (osn_var->softirq.delta_start) { + copy_int_safe_time(osn_var, &osn_var->thread.delta_start, + &osn_var->softirq.delta_start);Isn't softirq.delta_start going to be zero here? It doesn't look to get updated until you set
tracing_threadto true, but that happens here, and as this is in a interrupt context, there will not be a softirq happening between the setting of that to true to this point.
No... on the timerlat, the "sampling" is always on. And the osnoise_data.timerlat_tracer is only checked at the softirq return, so the softirq entry always set set the delta_start.
Quoted 38 lines
Quoted 38 lines
Documentation/trace/timerlat-tracer.rst new file +38
-0+ + copy_int_safe_time(osn_var, &osn_var->softirq.delta_start, + &osn_var->irq.delta_start); + } else { + copy_int_safe_time(osn_var, &osn_var->thread.delta_start, + &osn_var->irq.delta_start); + } +#else /* CONFIG_PREEMPT_RT */ + /* + * The sofirqs run as threads on RT, so there is not need + * to keep track of it. + */ + copy_int_safe_time(osn_var, &osn_var->thread.delta_start, &osn_var->irq.delta_start); +#endif /* CONFIG_PREEMPT_RT */ + + /* + * Compute the current time with the expected time. + */ + diff = now - tlat->abs_period; + + tlat->count++; + s.seqnum = tlat->count; + s.timer_latency = diff; + s.context = IRQ_CONTEXT; + + trace_timerlat_sample(&s); + + /* Keep a running maximum ever recorded os noise "latency" */ + if (diff > tr->max_latency) { + tr->max_latency = diff; + latency_fsnotify(tr); + } + + if (osnoise_data.stop_tracing_in) + if (time_to_us(diff) >= osnoise_data.stop_tracing_in) + osnoise_stop_tracing(); + + wake_up_process(tlat->kthread);
Quoted 8 lines
Documentation/trace/timerlat-tracer.rst static int osnoise_main(void *data) · line 1522
Quoted 5 lines
Documentation/trace/timerlat-tracer.rst new file +5
-0+ +#ifdef CONFIG_STACKTRACE + if (osnoise_data.print_stack) + timerlat_save_stack(0); +#endifNo need for the #ifdef above.
timerlat_save_stack()is defined as a nop when not enabled, and the compiler will just optimize this out.
The osnoise_data.print_stack is ifdefed, should I remove it from ifdef?
Quoted 57 lines
Quoted 42 lines
Documentation/trace/timerlat-tracer.rst new file +41
-0+ + return HRTIMER_NORESTART; +} + +/** + * wait_next_period - Wait for the next period for timerlat + */ +static int wait_next_period(struct timerlat_variables *tlat) +{ + ktime_t next_abs_period, now; + u64 rel_period = osnoise_data.timerlat_period * 1000; + + now = hrtimer_cb_get_time(&tlat->timer); + next_abs_period = ns_to_ktime(tlat->abs_period + rel_period); + + /* + * Save the next abs_period. + */ + tlat->abs_period = (u64) ktime_to_ns(next_abs_period); + + /* + * If the new abs_period is in the past, skip the activation. + */ + while (ktime_compare(now, next_abs_period) > 0) { + next_abs_period = ns_to_ktime(tlat->abs_period + rel_period); + tlat->abs_period = (u64) ktime_to_ns(next_abs_period); + } + + set_current_state(TASK_INTERRUPTIBLE); + + hrtimer_start(&tlat->timer, next_abs_period, HRTIMER_MODE_ABS_PINNED_HARD); + schedule(); + return 1; +} + +/** + * timerlat_main- Timerlat main + */ +static int timerlat_main(void *data) +{ + struct osnoise_variables *osn_var = this_cpu_osn_var();Documentation/trace/timerlat-tracer.rst static int osnoise_main(void *data) · line 1573
Quoted 10 lines
Documentation/trace/timerlat-tracer.rst new file +10
-0+ struct timerlat_variables *tlat = this_cpu_tmr_var(); + struct timerlat_sample s; + struct sched_param sp; + u64 now, diff; + + /* + * Make the thread RT, that is how cyclictest is usually used. + */ + sp.sched_priority = DEFAULT_TIMERLAT_PRIO; + sched_setscheduler_nocheck(current, SCHED_FIFO, &sp);Hmm, I thought Peter Zijlstra was removing all sched_setscheduler*() calls in the kernel :-/ Although, this one seems legit, and we are not running from within a module.
Quoted 2 lines
-- Steve
-- Daniel
Steven Rostedt
maintainerRe: [PATCH V3 9/9] tracing: Add timerlat tracer
Quoted 14 lines · On Fri, 11 Jun 2021 16:13:36 +0200 Daniel Bristot de Oliveira…
Quoted 5 lines
Quoted 5 lines
kernel/trace/trace_osnoise.c +5
-0+ +#ifdef CONFIG_STACKTRACE +/* +* Stack trace will take place only at IRQ level, so, no need +* to control nesting here. Quoted 8 lines
kernel/trace/trace_osnoise.c static void trace_osnoise_sample(struct osnoise_sample *sample) · line 358
Quoted 5 lines
+ */
kernel/trace/trace_osnoise.c +4
-0+struct trace_stack { +int stack_size; +int nr_entries; +unsigned long calls[PAGE_SIZE ];That is rather big. It's 8 *
PAGE_SIZE. I don't think that's what you really wanted.
Quoted 1 line
no, I did not want that... is 256 a good number?
Sure. But make it a macro.
#define MAX_CALLS 256
or something like that.
Quoted 138 lines
Quoted 9 lines
kernel/trace/trace_osnoise.c static void trace_osnoise_sample(struct osnoise_sample *sample) · line 363
Quoted 6 lines
kernel/trace/trace_osnoise.c +5
-0+}; + +static DEFINE_PER_CPU(struct trace_stack, trace_stack); + +/** Again, remove the KernelDoc notation of /**, or make it real kerneldoc notation.
Fixed!
[...]
Quoted 5 lines
Quoted 5 lines
*
kernel/trace/trace_osnoise.c +0
-0@@ -801,6 +1017,22 @@ void trace_softirq_exit_callback(void *data, unsigned int vec_nr)if (!osn_var->sampling)return ;Quoted 11 lines
kernel/trace/trace_osnoise.c void trace_softirq_exit_callback(void *data, unsigned int vec_nr) · line 1028
Quoted 9 lines
kernel/trace/trace_osnoise.c +9
-0+#ifdef CONFIG_TIMERLAT_TRACER +/* +* If the timerlat is enabled, but the irq handler did +* not run yet enabling timerlat_tracer, do not trace. +*/ +if (unlikely (osnoise_data.timerlat_tracer)) { +struct timerlat_variables *tlat_var; + tlat_var =this_cpu_tmr_var (); +if (!tlat_var->tracing_thread) {What happens if the timer interrupt triggers here?
The tracer will not report the softirq overhead. But at this point, the softirq is returning, and the duration would be from this time to...
Quoted 8 lines
kernel/trace/trace_osnoise.c void trace_softirq_exit_callback(void *data, unsigned int vec_nr) · line 1036
Quoted 8 lines
kernel/trace/trace_osnoise.c +7
-0+ osn_var->softirq.arrival_time =0 ; + osn_var->softirq.delta_start =0 ; + return; + } + } +#endif + duration =get_int_safe_duration (osn_var, &osn_var->softirq.delta_start);here.
We can disable interrupts to avoid this issue. But the question is, is it worth to disable interrupts to avoid this problem?
Quoted 6 lines
Quoted 6 lines
kernel/trace/trace_osnoise.c +0
-0trace_softirq_noise (vec_nr, osn_var->softirq.arrival_time, duration);cond_move_thread_delta_start (osn_var, duration);@@ -893,6 +1125,18 @@ thread_exit(struct osnoise_variables *osn_var, struct task_struct *t)if (!osn_var->sampling)return ;Quoted 7 lines
kernel/trace/trace_osnoise.c thread_exit(struct osnoise_variables *osn_var, struct task_struct *t) · line 1132
Quoted 5 lines
kernel/trace/trace_osnoise.c +5
-0+#ifdef CONFIG_TIMERLAT_TRACER +if (osnoise_data.timerlat_tracer) { +struct timerlat_variables *tlat_var; + tlat_var =this_cpu_tmr_var (); +if (!tlat_var->tracing_thread) {Or here?
The problem that can happen with the softirq cannot happen here: this code runs with interrupts disabled on
__schedule()(it is hooked to thesched_switch).Quoted 62 lines
Quoted 62 lines
kernel/trace/trace_osnoise.c +55
-0+ osn_var->thread.delta_start =0 ; + osn_var->thread.arrival_time =0 ; + return; + } + } +#endif + duration =get_int_safe_duration (osn_var, &osn_var->thread.delta_start);trace_thread_noise (t, osn_var->thread.arrival_time, duration);@@ -1182,6 +1426,197 @@ static int osnoise_main(void *data)return 0 ; } +#ifdef CONFIG_TIMERLAT_TRACER +/** +* timerlat_irq - hrtimer handler for timerlat. +*/ +static enum hrtimer_restart timerlat_irq (struct hrtimer *timer) +{ +struct osnoise_variables *osn_var =this_cpu_osn_var (); +struct trace_array *tr = osnoise_trace; +struct timerlat_variables *tlat; +struct timerlat_sample s; +u64 now; +u64 diff; + +/* +* I am not sure if the timer was armed for this CPU. So, get +* the timerlat struct from the timer itself, not from this +* CPU. +*/ + tlat = container_of(timer, struct timerlat_variables, timer); + + now =ktime_to_ns (hrtimer_cb_get_time (&tlat->timer)); + +/* +* Enable the osnoise: events for thread an softirq. +*/ + tlat->tracing_thread = true; + + osn_var->thread.arrival_time =time_get (); + +/* +* A hardirq is running: the timer IRQ. It is for sure preempting +* a thread, and potentially preempting a softirq. +* +* At this point, it is not interesting to know the duration of the +* preempted thread (and maybe softirq), but how much time they will +* delay the beginning of the execution of the timer thread. +* +* To get the correct (net) delay added by the softirq, its delta_start +* is set as the IRQ one. In this way, at the return of the IRQ, the delta +* start of the sofitrq will be zeroed, accounting then only the time +* after that. +* +* The thread follows the same principle. However, if a softirq is +* running, the thread needs to receive the softirq delta_start. The +* reason being is that the softirq will be the last to be unfolded, +* resseting the thread delay to zero. +*/ +#ifndef CONFIG_PREEMPT_RT Quoted 8 lines
kernel/trace/trace_osnoise.c static int osnoise_main(void *data) · line 1479
Quoted 3 lines
kernel/trace/trace_osnoise.c +3
-0+if (osn_var->softirq.delta_start) { +copy_int_safe_time (osn_var, &osn_var->thread.delta_start, + &osn_var->softirq.delta_start);Isn't softirq.delta_start going to be zero here? It doesn't look to get updated until you set
tracing_threadto true, but that happens here, and as this is in a interrupt context, there will not be a softirq happening between the setting of that to true to this point.
Quoted 3 lines
No... on the timerlat, the "sampling" is always on. And the osnoise_data.timerlat_tracer is only checked at the softirq return, so the softirq entry always set set the
delta_start.
OK, I was confused by the timerlat using the "__osnoise_tracer_start()". If timerlat is going to use that, perhaps we need to rename it, because the "osnoise" is one tracer, and its confusing that the "timerlat" is using functions called "*_osnoise_*". I was thinking that those functions were only for the osnoise tracer and not part of the timerlat tracer, and ignored them when looking at what the timerlat tracer was doing.
Can we rename that to simply "start_latency_tracing()" or something more generic.
Quoted 48 lines
Quoted 39 lines
Quoted 39 lines
kernel/trace/trace_osnoise.c +38
-0+ +copy_int_safe_time (osn_var, &osn_var->softirq.delta_start, + &osn_var->irq.delta_start); + }else { +copy_int_safe_time (osn_var, &osn_var->thread.delta_start, + &osn_var->irq.delta_start); + } +#else /* CONFIG_PREEMPT_RT */ +/* +* The sofirqs run as threads on RT, so there is not need +* to keep track of it. +*/ +copy_int_safe_time (osn_var, &osn_var->thread.delta_start, &osn_var->irq.delta_start); +#endif /* CONFIG_PREEMPT_RT */ + +/* +* Compute the current time with the expected time. +*/ + diff = now - tlat->abs_period; + + tlat->count++; + s.seqnum = tlat->count; + s.timer_latency = diff; + s.context =IRQ_CONTEXT ; + +trace_timerlat_sample (&s); + +/* Keep a running maximum ever recorded os noise "latency" */ +if (diff > tr->max_latency) { + tr->max_latency = diff; +latency_fsnotify (tr); + } + +if (osnoise_data.stop_tracing_in) +if (time_to_us (diff) >= osnoise_data.stop_tracing_in) +osnoise_stop_tracing (); + +wake_up_process (tlat->kthread);Quoted 8 lines
kernel/trace/trace_osnoise.c static int osnoise_main(void *data) · line 1522
Quoted 5 lines
kernel/trace/trace_osnoise.c +5
-0+ +#ifdef CONFIG_STACKTRACE +if (osnoise_data.print_stack) +timerlat_save_stack (0 ); +#endif No need for the #ifdef above.
timerlat_save_stack()is defined as a nop when not enabled, and the compiler will just optimize this out.
Quoted 1 line
The osnoise_data.print_stack is ifdefed, should I remove it from ifdef?
Well, the above ifdef is for STACKTRACE not for TIMERLAT_TRACER, which encompasses all of this. And the "timerlat_save_stack()" is a nop when STACKTRACE is not defined. So no.
-- Steve
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
kernel/trace/trace_osnoise.c +4
-0+ +return HRTIMER_NORESTART ; +} +
Re: [PATCH V3 9/9] tracing: Add timerlat tracer
Quoted 17 lines · Steven Rostedt
Quoted 14 lines · On Fri, 11 Jun 2021 16:13:36 +0200 Daniel Bristot de Oliveira…
Quoted 13 lines
kernel/trace/trace_osnoise.c static void trace_osnoise_sample(struct osnoise_sample *sample) · line 358
Quoted 10 lines
kernel/trace/trace_osnoise.c +10
-0+ +#ifdef CONFIG_STACKTRACE +/* + * Stack trace will take place only at IRQ level, so, no need + * to control nesting here. + */ +struct trace_stack { + int stack_size; + int nr_entries; + unsigned long calls[PAGE_SIZE];That is rather big. It's 8 *
PAGE_SIZE. I don't think that's what you really wanted.
Quoted 7 lines
Quoted 1 line
no, I did not want that... is 256 a good number?
Sure. But make it a macro.
#define
MAX_CALLS256or something like that.
Ack!
Quoted 149 lines
Quoted 138 lines
Quoted 9 lines
kernel/trace/trace_osnoise.c static void trace_osnoise_sample(struct osnoise_sample *sample) · line 363
Quoted 6 lines
kernel/trace/trace_osnoise.c +5
-0+}; + +static DEFINE_PER_CPU(struct trace_stack, trace_stack); + +/** Again, remove the KernelDoc notation of /**, or make it real kerneldoc notation.
Fixed!
[...]
Quoted 5 lines
Quoted 5 lines
*
kernel/trace/trace_osnoise.c +0
-0@@ -801,6 +1017,22 @@ void trace_softirq_exit_callback(void *data, unsigned int vec_nr)if (!osn_var->sampling)return ;Quoted 11 lines
kernel/trace/trace_osnoise.c void trace_softirq_exit_callback(void *data, unsigned int vec_nr) · line 1028
Quoted 9 lines
kernel/trace/trace_osnoise.c +9
-0+#ifdef CONFIG_TIMERLAT_TRACER +/* +* If the timerlat is enabled, but the irq handler did +* not run yet enabling timerlat_tracer, do not trace. +*/ +if (unlikely (osnoise_data.timerlat_tracer)) { +struct timerlat_variables *tlat_var; + tlat_var =this_cpu_tmr_var (); +if (!tlat_var->tracing_thread) {What happens if the timer interrupt triggers here?
The tracer will not report the softirq overhead. But at this point, the softirq is returning, and the duration would be from this time to...
Quoted 8 lines
kernel/trace/trace_osnoise.c void trace_softirq_exit_callback(void *data, unsigned int vec_nr) · line 1036
Quoted 8 lines
kernel/trace/trace_osnoise.c +7
-0+ osn_var->softirq.arrival_time =0 ; + osn_var->softirq.delta_start =0 ; + return; + } + } +#endif + duration =get_int_safe_duration (osn_var, &osn_var->softirq.delta_start);here.
We can disable interrupts to avoid this issue. But the question is, is it worth to disable interrupts to avoid this problem?
Quoted 6 lines
Quoted 6 lines
kernel/trace/trace_osnoise.c +0
-0trace_softirq_noise (vec_nr, osn_var->softirq.arrival_time, duration);cond_move_thread_delta_start (osn_var, duration);@@ -893,6 +1125,18 @@ thread_exit(struct osnoise_variables *osn_var, struct task_struct *t)if (!osn_var->sampling)return ;Quoted 7 lines
kernel/trace/trace_osnoise.c thread_exit(struct osnoise_variables *osn_var, struct task_struct *t) · line 1132
Quoted 5 lines
kernel/trace/trace_osnoise.c +5
-0+#ifdef CONFIG_TIMERLAT_TRACER +if (osnoise_data.timerlat_tracer) { +struct timerlat_variables *tlat_var; + tlat_var =this_cpu_tmr_var (); +if (!tlat_var->tracing_thread) {Or here?
The problem that can happen with the softirq cannot happen here: this code runs with interrupts disabled on
__schedule()(it is hooked to thesched_switch).Quoted 62 lines
Quoted 62 lines
kernel/trace/trace_osnoise.c +55
-0+ osn_var->thread.delta_start =0 ; + osn_var->thread.arrival_time =0 ; + return; + } + } +#endif + duration =get_int_safe_duration (osn_var, &osn_var->thread.delta_start);trace_thread_noise (t, osn_var->thread.arrival_time, duration);@@ -1182,6 +1426,197 @@ static int osnoise_main(void *data)return 0 ; } +#ifdef CONFIG_TIMERLAT_TRACER +/** +* timerlat_irq - hrtimer handler for timerlat. +*/ +static enum hrtimer_restart timerlat_irq (struct hrtimer *timer) +{ +struct osnoise_variables *osn_var =this_cpu_osn_var (); +struct trace_array *tr = osnoise_trace; +struct timerlat_variables *tlat; +struct timerlat_sample s; +u64 now; +u64 diff; + +/* +* I am not sure if the timer was armed for this CPU. So, get +* the timerlat struct from the timer itself, not from this +* CPU. +*/ + tlat = container_of(timer, struct timerlat_variables, timer); + + now =ktime_to_ns (hrtimer_cb_get_time (&tlat->timer)); + +/* +* Enable the osnoise: events for thread an softirq. +*/ + tlat->tracing_thread = true; + + osn_var->thread.arrival_time =time_get (); + +/* +* A hardirq is running: the timer IRQ. It is for sure preempting +* a thread, and potentially preempting a softirq. +* +* At this point, it is not interesting to know the duration of the +* preempted thread (and maybe softirq), but how much time they will +* delay the beginning of the execution of the timer thread. +* +* To get the correct (net) delay added by the softirq, its delta_start +* is set as the IRQ one. In this way, at the return of the IRQ, the delta +* start of the sofitrq will be zeroed, accounting then only the time +* after that. +* +* The thread follows the same principle. However, if a softirq is +* running, the thread needs to receive the softirq delta_start. The +* reason being is that the softirq will be the last to be unfolded, +* resseting the thread delay to zero. +*/ +#ifndef CONFIG_PREEMPT_RT Quoted 8 lines
kernel/trace/trace_osnoise.c static int osnoise_main(void *data) · line 1479
Quoted 3 lines
kernel/trace/trace_osnoise.c +3
-0+if (osn_var->softirq.delta_start) { +copy_int_safe_time (osn_var, &osn_var->thread.delta_start, + &osn_var->softirq.delta_start);Isn't softirq.delta_start going to be zero here? It doesn't look to get updated until you set
tracing_threadto true, but that happens here, and as this is in a interrupt context, there will not be a softirq happening between the setting of that to true to this point.Quoted 3 lines
No... on the timerlat, the "sampling" is always on. And the osnoise_data.timerlat_tracer is only checked at the softirq return, so the softirq entry always set set the
delta_start.OK, I was confused by the timerlat using the "
__osnoise_tracer_start()". If timerlat is going to use that, perhaps we need to rename it, because the "osnoise" is one tracer, and its confusing that the "timerlat" is using functions called "*_osnoise_*". I was thinking that those functions were only for the osnoise tracer and not part of the timerlat tracer, and ignored them when looking at what the timerlat tracer was doing.
Quoted 2 lines
Can we rename that to simply "
start_latency_tracing()" or something more generic.
right, also considering that we will (I hope) have the rtsl next, and other ideas coming around the usage of osnoise: events on other tracers, I also think should a more generic term to the events. Indeed, on rtsl they have a different name.
Thinking only about the instrumentation/events, what they are tracking is the execution time. So how about naming them as:
exec_time:thread
exec_time:irq
Also adding that, although here we measure the execution time of "task" context, on rtsl we have other kinds of "windows" that they measure, for instance, the poid window (Preemption or IRQ disabled). So, the term exec time also fits there.
?
Quoted 48 lines
Quoted 48 lines
Quoted 47 lines
Quoted 34 lines
kernel/trace/trace_osnoise.c +33
-0+ +copy_int_safe_time (osn_var, &osn_var->softirq.delta_start, + &osn_var->irq.delta_start); + }else { +copy_int_safe_time (osn_var, &osn_var->thread.delta_start, + &osn_var->irq.delta_start); + } +#else /* CONFIG_PREEMPT_RT */ +/* +* The sofirqs run as threads on RT, so there is not need +* to keep track of it. +*/ +copy_int_safe_time (osn_var, &osn_var->thread.delta_start, &osn_var->irq.delta_start); +#endif /* CONFIG_PREEMPT_RT */ + +/* +* Compute the current time with the expected time. +*/ + diff = now - tlat->abs_period; + + tlat->count++; + s.seqnum = tlat->count; + s.timer_latency = diff; + s.context =IRQ_CONTEXT ; + +trace_timerlat_sample (&s); + +/* Keep a running maximum ever recorded os noise "latency" */ +if (diff > tr->max_latency) { + tr->max_latency = diff; +latency_fsnotify (tr); + } +kernel/trace/trace_osnoise.c static int osnoise_main(void *data) · line 1522
Quoted 10 lines
kernel/trace/trace_osnoise.c +10
-0+if (osnoise_data.stop_tracing_in) +if (time_to_us (diff) >= osnoise_data.stop_tracing_in) +osnoise_stop_tracing (); + +wake_up_process (tlat->kthread); + +#ifdef CONFIG_STACKTRACE +if (osnoise_data.print_stack) +timerlat_save_stack (0 ); +#endif No need for the #ifdef above.
timerlat_save_stack()is defined as a nop when not enabled, and the compiler will just optimize this out.
Quoted 5 lines
Quoted 1 line
The osnoise_data.print_stack is ifdefed, should I remove it from ifdef?
Well, the above ifdef is for STACKTRACE not for
TIMERLAT_TRACER, which encompasses all of this. And the "timerlat_save_stack()" is a nop when STACKTRACE is not defined. So no.
Ooooppppsss, right, miss attention from my side.
-- Daniel
Quoted 9 lines
-- Steve
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
kernel/trace/trace_osnoise.c +4
-0+ +return HRTIMER_NORESTART ; +} +
Steven Rostedt
maintainerRe: [PATCH V3 9/9] tracing: Add timerlat tracer
Quoted 5 lines · On Sat, 12 Jun 2021 10:47:16 +0200 Daniel Bristot de Oliveira…
Thinking only about the instrumentation/events, what they are tracking is the execution time. So how about naming them as:
exec_time:thread
exec_time:irq
I guess. I should go and look at your other code.
Quoted 4 lines
Also adding that, although here we measure the execution time of "task" context, on rtsl we have other kinds of "windows" that they measure, for instance, the poid window (Preemption or IRQ disabled). So, the term exec time also fits there.
LOL at "poid"
-- Steve
Re: [PATCH V3 9/9] tracing: Add timerlat tracer
Quoted 10 lines · Steven Rostedt
Quoted 5 lines · On Sat, 12 Jun 2021 10:47:16 +0200 Daniel Bristot de Oliveira…
Thinking only about the instrumentation/events, what they are tracking is the execution time. So how about naming them as:
exec_time:thread
exec_time:irqI guess. I should go and look at your other code.
I have the v4 with all (including hotplug) execpt this name change. But as there are a lot of changes already, I will send it now, and keep thinking about this...
-- Daniel
Hi,
Quoted 29 lines · Daniel Bristot de Oliveira
This series proposes a set of improvements and new features for the tracing subsystem to facilitate the debugging of low latency deployments.
Currently, hwlat runs on a single CPU at a time, migrating across a set of CPUs in a round-robin fashion. This series improves hwlat to allow hwlat to run on multiple CPUs in parallel, increasing the chances of detecting a hardware latency, at the cost of using more CPU time.
It also proposes a new tracer named osnoise, that aims to help users of isolcpus= (or a similar method) to measure how much noise the OS and the hardware add to the isolated application. The osnoise tracer bases on the hwlat detector code. The difference is that, instead of sampling with interrupts disabled, the osnoise tracer samples the CPU with interrupts and preemption enabled. In this way, the sampling thread will suffer any source of noise from the OS. The detection and classification of the type of noise are then made by observing the entry points of NMIs, IRQs, SoftIRQs, and threads. If none of these sources of noise is detected, the tool associates the noise with the hardware. The tool periodically prints a status, printing the total noise of the period, the max single noise observed, the percentage of CPU available for the task, along with the counters of each source of the noise. To debug the sources of noise, the tracer also adds a set of tracepoints that print any NMI, IRQ, SofIRQ, and thread occurrence. These tracepoints print the starting time and the noise's net duration at the end of the noise. In this way, it reduces the number of tracepoints (one instead of two) and the need to manually accounting the contribution of each noise independently.
Quoted 16 lines
Finaly, the timerlat tracer aims to help the preemptive kernel developers to find sources of wakeup latencies of real-time threads. The tracer creates a per-cpu kernel thread with real-time priority. The tracer thread sets a periodic timer to wakeup itself, and goes to sleep waiting for the timer to fire. At the wakeup, the thread then computes a wakeup latency value as the difference between the current time and the absolute time that the timer was set to expire. The tracer prints two lines at every activation. The first is the timer latency observed at the hardirq context before the activation of the thread. The second is the timer latency observed by the thread, which is the same level that cyclictest reports. The ACTIVATION ID field serves to relate the irq execution to its respective thread execution. The tracer is build on top of osnoise tracer, and the osnoise: events can be used to trace the source of interference from NMI, IRQs and other threads. It also enables the capture of the stacktrace at the IRQ context, which helps to identify the code path that can cause thread delay.
FWIW, I've been using the new tracers extensively downstream for a while now and I find them very useful and quite more precise to detect problems than what we currently have available.
The fact that one can do almost everything needed to spot latency issues from entirely inside the kernel with a simple interface is a big plus to me as well.
I wouldn't mind if this gets accepted very soon! :)
Best,
Juri
Steven Rostedt
maintainerQuoted 9 lines · On Thu, 27 May 2021 14:07:37 +0200 Juri Lelli <[email protected]> wrote:
FWIW, I've been using the new tracers extensively downstream for a while now and I find them very useful and quite more precise to detect problems than what we currently have available.
The fact that one can do almost everything needed to spot latency issues from entirely inside the kernel with a simple interface is a big plus to me as well.
I wouldn't mind if this gets accepted very soon! :)
Neither would I ;-) But because of my extended vacation and other immediate responsibilities I need to take care of, it may be a couple of weeks before I can thoroughly look at this ;-)
Anyway, thanks for the vote of confidence.
-- Steve