tracing: Two fixes for 4.19
Subsystems (3)
Steven Rostedt
maintainerLinus (aka Greg),
This fixes two bugs:
- Fix size mismatch of tracepoint array
- Have preemptirq test module use same clock source of the selftest
Please pull the latest trace-v4.19-rc8 tree, which can be found at:
git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace.git
trace-v4.19-rc8
Tag SHA1: 3a6f9f3dd0418408f594c295e3b8ff6d3528460f Head SHA1: 12ad0cb2123aed30241a14792ef5bef9efcccbcd
Mathieu Desnoyers (1):
tracepoint: Fix tracepoint array element size mismatch
Steven Rostedt (VMware) (1):
tracing: Use trace_clock_local() for looping in preemptirq_delay_test.c
----
include/linux/module.h | 3 ++- include/linux/tracepoint-defs.h | 6 ++++++ include/linux/tracepoint.h | 36 +++++++++++++++++++++++------------- kernel/trace/preemptirq_delay_test.c | 10 +++++----- kernel/tracepoint.c | 24 ++++++++---------------- 5 files changed, 44 insertions(+), 35 deletions(-)
Steven Rostedt
maintainerPATCH 1/2 tracepoint: Fix tracepoint array element size mismatch
From: Mathieu Desnoyers <[email protected]>
commit 46e0c9be206f ("kernel: tracepoints: add support for relative references") changes the layout of the __tracepoint_ptrs section on architectures supporting relative references. However, it does so without turning struct tracepoint * const into const int elsewhere in the tracepoint code, which has the following side-effect:
Setting mod->num_tracepoints is done in by module.c:
mod->tracepoints_ptrs = section_objs(info, "__tracepoints_ptrs",
sizeof(*mod->tracepoints_ptrs),
&mod->num_tracepoints);Basically, since sizeof(*mod->tracepoints_ptrs) is a pointer size (rather than sizeof(int)), num_tracepoints is erroneously set to half the size it should be on 64-bit arch. So a module with an odd number of tracepoints misses the last tracepoint due to effect of integer division.
So in the module going notifier:
for_each_tracepoint_range(mod->tracepoints_ptrs,
mod->tracepoints_ptrs + mod->num_tracepoints,
tp_module_going_check_quiescent, NULL);the expression (mod->tracepoints_ptrs + mod->num_tracepoints) actually evaluates to something within the bounds of the array, but miss the last tracepoint if the number of tracepoints is odd on 64-bit arch.
Fix this by introducing a new typedef: tracepoint_ptr_t, which is either "const int" on architectures that have PREL32 relocations, or "struct tracepoint * const" on architectures that does not have this feature.
Also provide a new tracepoint_ptr_defer() static inline to encapsulate deferencing this type rather than duplicate code and ugly idefs within the for_each_tracepoint_range() implementation.
This issue appears in 4.19-rc kernels, and should ideally be fixed before the end of the rc cycle.
--- include/linux/module.h | 3 ++- include/linux/tracepoint-defs.h | 6 ++++++ include/linux/tracepoint.h | 36 +++++++++++++++++++++------------ kernel/tracepoint.c | 24 ++++++++-------------- 4 files changed, 39 insertions(+), 30 deletions(-)
include/linux/module.h +2 -1
@@ -20,6 +20,7 @@#include <linux/export.h> #include <linux/rbtree_latch.h> #include <linux/error-injection.h> +#include <linux/tracepoint-defs.h> #include <linux/percpu.h> #include <asm/module.h>
@@ -430,7 +431,7 @@ struct module {#ifdef CONFIG_TRACEPOINTS unsigned int num_tracepoints; -struct tracepoint *const *tracepoints_ptrs; +tracepoint_ptr_t *tracepoints_ptrs;#endif #ifdef HAVE_JUMP_LABEL struct jump_entry *jump_entries;
include/linux/tracepoint-defs.h +6 -0
@@ -35,6 +35,12 @@ struct tracepoint {struct tracepoint_func __rcu *funcs; }; +#ifdef CONFIG_HAVE_ARCH_PREL32_RELOCATIONS +typedef const int tracepoint_ptr_t ; +#else +typedef struct tracepoint *const tracepoint_ptr_t ; +#endif +struct bpf_raw_event_map {struct tracepoint *tp;void *bpf_func;
include/linux/tracepoint.h +23 -13
@@ -99,6 +99,29 @@ extern void syscall_unregfunc(void);#define TRACE_DEFINE_ENUM (x)#define TRACE_DEFINE_SIZEOF (x) +#ifdef CONFIG_HAVE_ARCH_PREL32_RELOCATIONS +static inline struct tracepoint *tracepoint_ptr_deref (tracepoint_ptr_t *p) +{ +return offset_to_ptr (p); +} + +#define __TRACEPOINT_ENTRY (name) \ + asm(" .section \"__tracepoints_ptrs\", \"a\" \n" \ + " .balign 4 \n" \ + " .long __tracepoint_" #name " - . \n" \ + " .previous \n") +#else +static inline struct tracepoint *tracepoint_ptr_deref (tracepoint_ptr_t *p) +{ +return *p; +} + +#define __TRACEPOINT_ENTRY (name) \ + static tracepoint_ptr_t __tracepoint_ptr_##name __used \ + __attribute__((section("__tracepoints_ptrs"))) = \ + &__tracepoint_##name +#endif +#endif /* _LINUX_TRACEPOINT_H */ /*
@@ -253,19 +276,6 @@ extern void syscall_unregfunc(void); return static_key_false(&__tracepoint_##name.key); \ } -#ifdef CONFIG_HAVE_ARCH_PREL32_RELOCATIONS -#define __TRACEPOINT_ENTRY (name) \ - asm(" .section \"__tracepoints_ptrs\", \"a\" \n" \ - " .balign 4 \n" \ - " .long __tracepoint_" #name " - . \n" \ - " .previous \n") -#else -#define __TRACEPOINT_ENTRY (name) \ - static struct tracepoint * const __tracepoint_ptr_##name __used \ - __attribute__((section("__tracepoints_ptrs"))) = \ - &__tracepoint_##name -#endif -/* * We have no guarantee that gcc and the linker won't up-align the tracepoint * structures, so we create an array of pointers that will be used for iteration
kernel/tracepoint.c +8 -16
@@ -28,8 +28,8 @@#include <linux/sched/task.h> #include <linux/static_key.h> -extern struct tracepoint *const __start___tracepoints_ptrs[]; -extern struct tracepoint *const __stop___tracepoints_ptrs[]; +extern tracepoint_ptr_t __start___tracepoints_ptrs[]; +extern tracepoint_ptr_t __stop___tracepoints_ptrs[];DEFINE_SRCU (tracepoint_srcu);EXPORT_SYMBOL_GPL (tracepoint_srcu);
@@ -371,25 +371,17 @@ int tracepoint_probe_unregister(struct tracepoint *tp, void *probe, void *data) }EXPORT_SYMBOL_GPL (tracepoint_probe_unregister); -static void for_each_tracepoint_range (struct tracepoint *const *begin, -struct tracepoint *const *end, +static void for_each_tracepoint_range ( +tracepoint_ptr_t *begin,tracepoint_ptr_t *end,void (*fct)(struct tracepoint *tp,void *priv),void *priv) { +tracepoint_ptr_t *iter; +if (!begin)return ; - -if (IS_ENABLED (CONFIG_HAVE_ARCH_PREL32_RELOCATIONS )) { -const int *iter; - -for (iter = (const int *)begin; iter < (const int *)end; iter++) -fct (offset_to_ptr (iter), priv); - }else { -struct tracepoint *const *iter; - -for (iter = begin; iter < end; iter++) -fct (*iter, priv); - } +for (iter = begin; iter < end; iter++) +fct (tracepoint_ptr_deref (iter), priv); }#ifdef CONFIG_MODULES
Signature · 1 line
2.19.0
Steven Rostedt
maintainerPATCH 2/2 tracing: Use trace_clock_local() for looping in preemptirq_delay_test.c
In reply to Steven RostedtFrom: "Steven Rostedt (VMware)" <[email protected]>
The preemptirq_delay_test module is used for the ftrace selftest code that tests the latency tracers. The problem is that it uses ktime for the delay loop, and then checks the tracer to see if the delay loop is caught, but the tracer uses trace_clock_local() which uses various different other clocks to measure the latency. As ktime uses the clock cycles, and the code then converts that to nanoseconds, it causes rounding errors, and the preemptirq latency tests are failing due to being off by 1 (it expects to see a delay of 500000 us, but the delay is only 499999 us). This is happening due to a rounding error in the ktime (which is totally legit). The purpose of the test is to see if it can catch the delay, not to test the accuracy between trace_clock_local() and ktime_get(). Best to use apples to apples, and have the delay loop use the same clock as the latency tracer does.
--- kernel/trace/preemptirq_delay_test.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-)
kernel/trace/preemptirq_delay_test.c +5 -5
@@ -5,12 +5,12 @@* Copyright (C) 2018 Joel Fernandes (Google) <[email protected]> */ +#include <linux/trace_clock.h> #include <linux/delay.h> #include <linux/interrupt.h> #include <linux/irq.h> #include <linux/kernel.h> #include <linux/kthread.h> -#include <linux/ktime.h> #include <linux/module.h> #include <linux/printk.h> #include <linux/string.h>
@@ -25,13 +25,13 @@ MODULE_PARM_DESC(test_mode, "Mode of the test such as preempt or irq (default irstatic void busy_wait (ulong time) { -ktime_t start, end; - start =ktime_get (); +u64 start, end; + start =trace_clock_local ();do { - end =ktime_get (); + end =trace_clock_local ();if (kthread_should_stop ())break ; - }while (ktime_to_ns (ktime_sub (end, start)) < (time *1000 )); + }while ((end - start) < (time *1000 )); }static int preemptirq_delay_run (void *data)
Signature · 1 line
2.19.0
Greg Kroah-Hartman
maintainerQuoted 8 lines · Steven Rostedt
Linus (aka Greg),
This fixes two bugs:
- Fix size mismatch of tracepoint array
- Have preemptirq test module use same clock source of the selftest
Now pulled, thanks.
greg k-h