tracing: More updates for 5.5
Subsystems (5)
Steven Rostedt
maintainercover tracing: More updates for 5.5
git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace.git
for-next
Head SHA1: 16c0f03f629a89e6a1249497202b2c154ff46206
Alexei Starovoitov (1):
ftrace: Return ENOTSUPP when DYNAMIC_FTRACE_WITH_DIRECT_CALLS is not configured
Divya Indi (2):
tracing: Adding new functions for kernel access to Ftrace instances
tracing: Sample module to demonstrate kernel access to Ftrace instances.
Enrico Weigelt, metux IT consult (1):
ftrace: Use BIT() macro
Hassan Naveed (2):
tracing: Use xarray for syscall trace events
tracing: Enable syscall optimization for MIPS
Krzysztof Kozlowski (1):
tracing: Fix Kconfig indentation
Steven Rostedt (VMware) (2):
ftrace: Add a helper function to modify_ftrace_direct() to allow arch optimization
ftrace: Rename ftrace_graph_stub to ftrace_stub_graph
Xianting Tian (1):
ring-buffer: Fix typos in function ring_buffer_producer
----
arch/Kconfig | 8 +++ arch/mips/Kconfig | 1 + include/asm-generic/vmlinux.lds.h | 8 +-- include/linux/ftrace.h | 63 +++++++++++------ include/linux/trace.h | 3 +- include/linux/trace_events.h | 3 +- kernel/trace/Kconfig | 8 +-- kernel/trace/fgraph.c | 6 +- kernel/trace/ftrace.c | 120 +++++++++++++++++++++++--------- kernel/trace/ring_buffer_benchmark.c | 4 +- kernel/trace/trace.c | 96 +++++++++++++++++++------ kernel/trace/trace.h | 1 - kernel/trace/trace_events.c | 27 +++++++- kernel/trace/trace_syscalls.c | 32 +++++++-- samples/Kconfig | 7 ++ samples/Makefile | 1 + samples/ftrace/Makefile | 3 + samples/ftrace/sample-trace-array.c | 131 +++++++++++++++++++++++++++++++++++ samples/ftrace/sample-trace-array.h | 84 ++++++++++++++++++++++ 19 files changed, 507 insertions(+), 99 deletions(-) create mode 100644 samples/ftrace/sample-trace-array.c create mode 100644 samples/ftrace/sample-trace-array.h
Steven Rostedt
maintainerPATCH 3/10 ftrace: Return ENOTSUPP when DYNAMIC_FTRACE_WITH_DIRECT_CALLS is not configured
From: Alexei Starovoitov <[email protected]>
When CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS is not set it's best to have the stub functions return ENOTSUPP instead of ENODEV, otherwise ENODEV is a valid error when ip is incorrect which is indistinguishable from ftrace not compiled in.
--- include/linux/ftrace.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
include/linux/ftrace.h +3 -3
@@ -268,16 +268,16 @@ int ftrace_modify_direct_caller(struct ftrace_func_entry *entry,# define ftrace_direct_func_count 0static inline int register_ftrace_direct (unsigned long ip,unsigned long addr) { -return -ENODEV ; +return -ENOTSUPP ; }static inline int unregister_ftrace_direct (unsigned long ip,unsigned long addr) { -return -ENODEV ; +return -ENOTSUPP ; }static inline int modify_ftrace_direct (unsigned long ip,unsigned long old_addr,unsigned long new_addr) { -return -ENODEV ; +return -ENOTSUPP ; }static inline struct ftrace_direct_func *ftrace_find_direct_func (unsigned long addr) {
Signature · 1 line
2.24.0
Steven Rostedt
maintainerPATCH 1/10 ftrace: Add a helper function to modify_ftrace_direct() to allow arch optimization
In reply to Steven RostedtFrom: "Steven Rostedt (VMware)" <[email protected]>
If a direct ftrace callback is at a location that does not have any other ftrace helpers attached to it, it is possible to simply just change the text to call the new caller (if the architecture supports it). But this requires special architecture code. Currently, modify_ftrace_direct() uses a trick to add a stub ftrace callback to the location forcing it to call the ftrace iterator. Then it can change the direct helper to call the new function in C, and then remove the stub. Removing the stub will have the location now call the new location that the direct helper is using.
The new helper function does the registering the stub trick, but is a weak function, allowing an architecture to override it to do something a bit more direct.
--- include/linux/ftrace.h | 21 +++++++- kernel/trace/ftrace.c | 120 ++++++++++++++++++++++++++++++----------- 2 files changed, 107 insertions(+), 34 deletions(-)
include/linux/ftrace.h +19 -2
@@ -246,12 +246,24 @@ static inline void ftrace_free_init_mem(void) { }static inline void ftrace_free_mem (struct module *mod,void *start,void *end) { }#endif /* CONFIG_FUNCTION_TRACER */ +struct ftrace_func_entry { +struct hlist_node hlist; +unsigned long ip; +unsigned long direct;/* for direct lookup only */ +}; + +struct dyn_ftrace ; +#ifdef CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS extern int ftrace_direct_func_count;int register_ftrace_direct (unsigned long ip,unsigned long addr);int unregister_ftrace_direct (unsigned long ip,unsigned long addr);int modify_ftrace_direct (unsigned long ip,unsigned long old_addr,unsigned long new_addr);struct ftrace_direct_func *ftrace_find_direct_func (unsigned long addr); +int ftrace_modify_direct_caller (struct ftrace_func_entry *entry, +struct dyn_ftrace *rec, +unsigned long old_addr, +unsigned long new_addr);#else # define ftrace_direct_func_count 0static inline int register_ftrace_direct (unsigned long ip,unsigned long addr)
@@ -271,6 +283,13 @@ static inline struct ftrace_direct_func *ftrace_find_direct_func(unsigned long a {return NULL ; } +static inline int ftrace_modify_direct_caller (struct ftrace_func_entry *entry, +struct dyn_ftrace *rec, +unsigned long old_addr, +unsigned long new_addr) +{ +return -ENODEV ; +}#endif /* CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS */ #ifndef CONFIG_HAVE_DYNAMIC_FTRACE_WITH_DIRECT_CALLS
@@ -343,8 +362,6 @@ static inline void stack_tracer_enable(void) { }int ftrace_arch_code_modify_prepare (void );int ftrace_arch_code_modify_post_process (void ); -struct dyn_ftrace ; -enum ftrace_bug_type {FTRACE_BUG_UNKNOWN ,FTRACE_BUG_INIT ,
kernel/trace/ftrace.c +88 -32
170 lines not on this page · raw message
Signature · 1 line
2.24.0
Steven Rostedt
maintainerPATCH 4/10 ftrace: Use BIT() macro
In reply to Steven RostedtFrom: "Enrico Weigelt, metux IT consult" <[email protected]>
It's cleaner to use the BIT() macro instead of raw shift operation.
--- include/linux/ftrace.h | 36 ++++++++++++++++++------------------ 1 file changed, 18 insertions(+), 18 deletions(-)
include/linux/ftrace.h +18 -18
@@ -149,24 +149,24 @@ ftrace_func_t ftrace_ops_get_func(struct ftrace_ops *ops);* (internal ftrace only, should not be used by others) */ enum { -FTRACE_OPS_FL_ENABLED =1 <<0 , -FTRACE_OPS_FL_DYNAMIC =1 <<1 , -FTRACE_OPS_FL_SAVE_REGS =1 <<2 , -FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED =1 <<3 , -FTRACE_OPS_FL_RECURSION_SAFE =1 <<4 , -FTRACE_OPS_FL_STUB =1 <<5 , -FTRACE_OPS_FL_INITIALIZED =1 <<6 , -FTRACE_OPS_FL_DELETED =1 <<7 , -FTRACE_OPS_FL_ADDING =1 <<8 , -FTRACE_OPS_FL_REMOVING =1 <<9 , -FTRACE_OPS_FL_MODIFYING =1 <<10 , -FTRACE_OPS_FL_ALLOC_TRAMP =1 <<11 , -FTRACE_OPS_FL_IPMODIFY =1 <<12 , -FTRACE_OPS_FL_PID =1 <<13 , -FTRACE_OPS_FL_RCU =1 <<14 , -FTRACE_OPS_FL_TRACE_ARRAY =1 <<15 , -FTRACE_OPS_FL_PERMANENT =1 <<16 , -FTRACE_OPS_FL_DIRECT =1 <<17 , +FTRACE_OPS_FL_ENABLED =BIT (0 ), +FTRACE_OPS_FL_DYNAMIC =BIT (1 ), +FTRACE_OPS_FL_SAVE_REGS =BIT (2 ), +FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED =BIT (3 ), +FTRACE_OPS_FL_RECURSION_SAFE =BIT (4 ), +FTRACE_OPS_FL_STUB =BIT (5 ), +FTRACE_OPS_FL_INITIALIZED =BIT (6 ), +FTRACE_OPS_FL_DELETED =BIT (7 ), +FTRACE_OPS_FL_ADDING =BIT (8 ), +FTRACE_OPS_FL_REMOVING =BIT (9 ), +FTRACE_OPS_FL_MODIFYING =BIT (10 ), +FTRACE_OPS_FL_ALLOC_TRAMP =BIT (11 ), +FTRACE_OPS_FL_IPMODIFY =BIT (12 ), +FTRACE_OPS_FL_PID =BIT (13 ), +FTRACE_OPS_FL_RCU =BIT (14 ), +FTRACE_OPS_FL_TRACE_ARRAY =BIT (15 ), +FTRACE_OPS_FL_PERMANENT =BIT (16 ), +FTRACE_OPS_FL_DIRECT =BIT (17 ), };#ifdef CONFIG_DYNAMIC_FTRACE
Signature · 1 line
2.24.0
Steven Rostedt
maintainerPATCH 8/10 tracing: Sample module to demonstrate kernel access to Ftrace instances.
In reply to Steven RostedtFrom: Divya Indi <[email protected]>
This is a sample module to demonstrate the use of the newly introduced and exported APIs to access Ftrace instances from within the kernel.
Newly introduced APIs used here -
1. Create/Lookup a trace array with the given name. struct trace_array *trace_array_get_by_name(const char *name)
2. Destroy/Remove a trace array.
int trace_array_destroy(struct trace_array *tr)
4. Enable/Disable trace events:
int trace_array_set_clr_event(struct trace_array *tr, const char *system,
const char *event, bool enable);
Exported APIs -
1. trace_printk equivalent for instances.
int trace_array_printk(struct trace_array *tr,
unsigned long ip, const char *fmt, ...);
2. Helper function.
void trace_printk_init_buffers(void);
3. To decrement the reference counter.
void trace_array_put(struct trace_array *tr)
Sample output(contents of /sys/kernel/tracing/instances/sample-instance)
NOTE: Tracing disabled after ~5 sec)
_-----=> irqs-off
/ _----=> need-resched
| / _---=> hardirq/softirq
|| / _--=> preempt-depth
||| / delay
TASK-PID CPU# |||| TIMESTAMP FUNCTION
| | | |||| | |
sample-instance-1452 [002] .... 49.430948: simple_thread: trace_array_printk: count=0
sample-instance-1452 [002] .... 49.430951: sample_event: count value=0 at jiffies=4294716608
sample-instance-1452 [002] .... 50.454847: simple_thread: trace_array_printk: count=1
sample-instance-1452 [002] .... 50.454849: sample_event: count value=1 at jiffies=4294717632
sample-instance-1452 [002] .... 51.478748: simple_thread: trace_array_printk: count=2
sample-instance-1452 [002] .... 51.478750: sample_event: count value=2 at jiffies=4294718656
sample-instance-1452 [002] .... 52.502652: simple_thread: trace_array_printk: count=3
sample-instance-1452 [002] .... 52.502655: sample_event: count value=3 at jiffies=4294719680
sample-instance-1452 [002] .... 53.526533: simple_thread: trace_array_printk: count=4
sample-instance-1452 [002] .... 53.526535: sample_event: count value=4 at jiffies=4294720704
sample-instance-1452 [002] .... 54.550438: simple_thread: trace_array_printk: count=5
sample-instance-1452 [002] .... 55.574336: simple_thread: trace_array_printk: count=6--- samples/Kconfig | 7 ++ samples/Makefile | 1 + samples/ftrace/Makefile | 3 + samples/ftrace/sample-trace-array.c | 131 ++++++++++++++++++++++++++++ samples/ftrace/sample-trace-array.h | 84 ++++++++++++++++++ 5 files changed, 226 insertions(+) create mode 100644 samples/ftrace/sample-trace-array.c create mode 100644 samples/ftrace/sample-trace-array.h
samples/Kconfig +7 -0
@@ -27,6 +27,13 @@ config SAMPLE_FTRACE_DIRECT This builds an ftrace direct function example that hooks to wake_up_process and prints the parameters. +config SAMPLE_TRACE_ARRAY + tristate "Build sample module for kernel access to Ftrace instancess" + depends on EVENT_TRACING && m + help + This builds a module that demonstrates the use of various APIs to + access Ftrace instances from within the kernel. + config SAMPLE_KOBJECT tristate "Build kobject examples" help
samples/Makefile +1 -0
@@ -18,6 +18,7 @@ subdir-$(CONFIG_SAMPLE_SECCOMP) += seccomp obj-$(CONFIG_SAMPLE_TRACE_EVENTS) += trace_events/ obj-$(CONFIG_SAMPLE_TRACE_PRINTK) += trace_printk/ obj-$(CONFIG_SAMPLE_FTRACE_DIRECT) += ftrace/ +obj-$(CONFIG_SAMPLE_TRACE_ARRAY) += ftrace/ obj-$(CONFIG_VIDEO_PCI_SKELETON) += v4l/ obj-y += vfio-mdev/ subdir-$(CONFIG_SAMPLE_VFS) += vfs
samples/ftrace/Makefile +3 -0
@@ -3,3 +3,6 @@ obj-$(CONFIG_SAMPLE_FTRACE_DIRECT) += ftrace-direct.o obj-$(CONFIG_SAMPLE_FTRACE_DIRECT) += ftrace-direct-too.o obj-$(CONFIG_SAMPLE_FTRACE_DIRECT) += ftrace-direct-modify.o + +CFLAGS_sample-trace-array.o := -I$(src) +obj-$(CONFIG_SAMPLE_TRACE_ARRAY) += sample-trace-array.o
samples/ftrace/sample-trace-array.c new file +131 -0
131 lines not on this page · raw message
samples/ftrace/sample-trace-array.h new file +84 -0
84 lines not on this page · raw message
Signature · 1 line
2.24.0
Steven Rostedt
maintainerPATCH 9/10 tracing: Use xarray for syscall trace events
In reply to Steven RostedtFrom: Hassan Naveed <[email protected]>
Currently, a lot of memory is wasted for architectures like MIPS when init_ftrace_syscalls() allocates the array for syscalls using kcalloc. This is because syscalls numbers start from 4000, 5000 or 6000 and array elements up to that point are unused.
Fix this by using a data structure more suited to storing sparsely populated arrays. The XARRAY data structure, implemented using radix trees, is much more memory efficient for storing the syscalls in question.
--- arch/Kconfig | 8 ++++++++ kernel/trace/trace_syscalls.c | 32 +++++++++++++++++++++++++------- 2 files changed, 33 insertions(+), 7 deletions(-)
arch/Kconfig +8 -0
@@ -960,6 +960,14 @@ config RELR config ARCH_HAS_MEM_ENCRYPT bool +config HAVE_SPARSE_SYSCALL_NR + bool + help + An architecture should select this if its syscall numbering is sparse + to save space. For example, MIPS architecture has a syscall array with + entries at 4000, 5000 and 6000 locations. This option turns on syscall + related optimizations for a given architecture. + source "kernel/gcov/Kconfig" source "scripts/gcc-plugins/Kconfig"
kernel/trace/trace_syscalls.c +25 -7
@@ -7,6 +7,7 @@#include <linux/module.h> /* for MODULE_NAME_LEN via KSYM_SYMBOL_LEN */ #include <linux/ftrace.h> #include <linux/perf_event.h> +#include <linux/xarray.h> #include <asm/syscall.h> #include "trace_output.h"
@@ -30,6 +31,7 @@ syscall_get_enter_fields(struct trace_event_call *call)extern struct syscall_metadata *__start_syscalls_metadata[];extern struct syscall_metadata *__stop_syscalls_metadata[]; +static DEFINE_XARRAY (syscalls_metadata_sparse);static struct syscall_metadata **syscalls_metadata;#ifndef ARCH_HAS_SYSCALL_MATCH_SYM_NAME
@@ -101,6 +103,9 @@ find_syscall_meta(unsigned long syscall)static struct syscall_metadata *syscall_nr_to_meta (int nr) { +if (IS_ENABLED (CONFIG_HAVE_SPARSE_SYSCALL_NR )) +return xa_load (&syscalls_metadata_sparse, (unsigned long )nr); +if (!syscalls_metadata || nr >= NR_syscalls || nr <0 )return NULL ;
@@ -536,12 +541,16 @@ void __init init_ftrace_syscalls(void)struct syscall_metadata *meta;unsigned long addr;int i; - - syscalls_metadata =kcalloc (NR_syscalls,sizeof (*syscalls_metadata), -GFP_KERNEL ); -if (!syscalls_metadata) { -WARN_ON (1 ); -return ; +void *ret; + +if (!IS_ENABLED (CONFIG_HAVE_SPARSE_SYSCALL_NR )) { + syscalls_metadata =kcalloc (NR_syscalls, +sizeof (*syscalls_metadata), +GFP_KERNEL ); +if (!syscalls_metadata) { +WARN_ON (1 ); +return ; + } }for (i =0 ; i < NR_syscalls; i++) {
@@ -551,7 +560,16 @@ void __init init_ftrace_syscalls(void)continue ; meta->syscall_nr = i; - syscalls_metadata[i] = meta; + +if (!IS_ENABLED (CONFIG_HAVE_SPARSE_SYSCALL_NR )) { + syscalls_metadata[i] = meta; + }else { + ret =xa_store (&syscalls_metadata_sparse, i, meta, +GFP_KERNEL ); +WARN (xa_is_err (ret), +"Syscall memory allocation failed\n" ); + } + } }
Signature · 1 line
2.24.0
Steven Rostedt
maintainerPATCH 10/10 tracing: Enable syscall optimization for MIPS
In reply to Steven RostedtFrom: Hassan Naveed <[email protected]>
Since MIPS architecture has a sparse syscall array, select the HAVE_SPARSE_SYSCALL_NR to save space.
--- arch/mips/Kconfig | 1 + 1 file changed, 1 insertion(+)
arch/mips/Kconfig +1 -0
@@ -73,6 +73,7 @@ config MIPS select HAVE_PERF_EVENTS select HAVE_REGS_AND_STACK_ACCESS_API select HAVE_RSEQ + select HAVE_SPARSE_SYSCALL_NR select HAVE_STACKPROTECTOR select HAVE_SYSCALL_TRACEPOINTS select HAVE_VIRT_CPU_ACCOUNTING_GEN if 64BIT || !SMP
Signature · 1 line
2.24.0
Steven Rostedt
maintainerPATCH 7/10 tracing: Adding new functions for kernel access to Ftrace instances
In reply to Steven RostedtFrom: Divya Indi <[email protected]>
Adding 2 new functions -
1) struct trace_array *trace_array_get_by_name(const char *name);
Return pointer to a trace array with given name. If it does not exist, create and return pointer to the new trace array.
2) int trace_array_set_clr_event(struct trace_array *tr, const char *system ,const char *event, bool enable);
Enable/Disable events to this trace array.
Additionally,
- To handle reference counters, export trace_array_put()
- Due to introduction of the above 2 new functions, we no longer need to export - ftrace_set_clr_event & trace_array_create APIs.
--- include/linux/trace.h | 3 +- include/linux/trace_events.h | 3 +- kernel/trace/trace.c | 96 ++++++++++++++++++++++++++++-------- kernel/trace/trace.h | 1 - kernel/trace/trace_events.c | 27 +++++++++- 5 files changed, 106 insertions(+), 24 deletions(-)
include/linux/trace.h +2 -1
@@ -29,7 +29,8 @@ struct trace_array;void trace_printk_init_buffers (void );int trace_array_printk (struct trace_array *tr,unsigned long ip,const char *fmt, ...); -struct trace_array *trace_array_create (const char *name); +void trace_array_put (struct trace_array *tr); +struct trace_array *trace_array_get_by_name (const char *name);int trace_array_destroy (struct trace_array *tr);#endif /* CONFIG_TRACING */
include/linux/trace_events.h +2 -1
@@ -555,7 +555,8 @@ extern int trace_event_get_offsets(struct trace_event_call *call);int ftrace_set_clr_event (struct trace_array *tr,char *buf,int set);int trace_set_clr_event (const char *system,const char *event,int set); - +int trace_array_set_clr_event (struct trace_array *tr,const char *system, +const char *event,bool enable);/* * The double __builtin_constant_p is because gcc will give us an error * if we try to allocate the static variable to fmt if it is not a
kernel/trace/trace.c +76 -20
144 lines not on this page · raw message
kernel/trace/trace.h +0 -1
@@ -345,7 +345,6 @@ extern struct list_head ftrace_trace_arrays;extern struct mutex trace_types_lock;extern int trace_array_get (struct trace_array *tr); -extern void trace_array_put (struct trace_array *tr);extern int tracing_check_open_get_tr (struct trace_array *tr);extern int tracing_set_time_stamp_abs (struct trace_array *tr,bool abs);
kernel/trace/trace_events.c +26 -1
@@ -827,7 +827,6 @@ int ftrace_set_clr_event(struct trace_array *tr, char *buf, int set)return ret; } -EXPORT_SYMBOL_GPL (ftrace_set_clr_event);/** * trace_set_clr_event - enable or disable an event
@@ -852,6 +851,32 @@ int trace_set_clr_event(const char *system, const char *event, int set) }EXPORT_SYMBOL_GPL (trace_set_clr_event); +/** +* trace_array_set_clr_event - enable or disable an event for a trace array. +* @tr: concerned trace array. +* @system: system name to match (NULL for any system) +* @event: event name to match (NULL for all events, within system) +* @enable: true to enable, false to disable +* +* This is a way for other parts of the kernel to enable or disable +* event recording. +* +* Returns 0 on success, -EINVAL if the parameters do not match any +* registered events. +*/ +int trace_array_set_clr_event (struct trace_array *tr,const char *system, +const char *event,bool enable) +{ +int set; + +if (!tr) +return -ENOENT ; + + set = (enable == true) ?1 :0 ; +return __ftrace_set_clr_event (tr,NULL , system, event, set); +} +EXPORT_SYMBOL_GPL (trace_array_set_clr_event); +/* 128 should be much more than enough */ #define EVENT_BUF_SIZE 127
Signature · 1 line
2.24.0
Steven Rostedt
maintainerPATCH 5/10 ring-buffer: Fix typos in function ring_buffer_producer
In reply to Steven RostedtFrom: Xianting Tian <[email protected]>
Fix spelling and other typos
--- kernel/trace/ring_buffer_benchmark.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
kernel/trace/ring_buffer_benchmark.c +2 -2
@@ -269,10 +269,10 @@ static void ring_buffer_producer(void)#ifndef CONFIG_PREEMPTION /* -* If we are a non preempt kernel, the 10 second run will +* If we are a non preempt kernel, the 10 seconds run will * stop everything while it runs. Instead, we will call * cond_resched and also add any time that was lost by a -* rescedule. +* reschedule. * * Do a cond resched at the same frequency we would wake up * the reader.
Signature · 1 line
2.24.0
Steven Rostedt
maintainerPATCH 6/10 tracing: Fix Kconfig indentation
In reply to Steven RostedtFrom: Krzysztof Kozlowski <[email protected]>
Adjust indentation from spaces to tab (+optional two spaces) as in coding style with command like:
$ sed -e 's/^ /\t/' -i */Kconfig
--- kernel/trace/Kconfig | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
kernel/trace/Kconfig +4 -4
@@ -79,7 +79,7 @@ config FTRACE_NMI_ENTER config EVENT_TRACING select CONTEXT_SWITCH_TRACER - select GLOB + select GLOB bool config CONTEXT_SWITCH_TRACER
@@ -311,7 +311,7 @@ config TRACER_SNAPSHOT cat snapshot config TRACER_SNAPSHOT_PER_CPU_SWAP - bool "Allow snapshot to swap per CPU" + bool "Allow snapshot to swap per CPU" depends on TRACER_SNAPSHOT select RING_BUFFER_ALLOW_SWAP help
@@ -683,7 +683,7 @@ config MMIOTRACE_TEST Say N, unless you absolutely know what you are doing. config TRACEPOINT_BENCHMARK - bool "Add tracepoint that benchmarks tracepoints" + bool "Add tracepoint that benchmarks tracepoints" help This option creates the tracepoint "benchmark:benchmark_event". When the tracepoint is enabled, it kicks off a kernel thread that
@@ -732,7 +732,7 @@ config RING_BUFFER_STARTUP_TEST bool "Ring buffer startup self test" depends on RING_BUFFER help - Run a simple self test on the ring buffer on boot up. Late in the + Run a simple self test on the ring buffer on boot up. Late in the kernel boot sequence, the test will start that kicks off a thread per cpu. Each thread will write various size events into the ring buffer. Another thread is created to send IPIs
Signature · 1 line
2.24.0
Steven Rostedt
maintainerPATCH 2/10 ftrace: Rename ftrace_graph_stub to ftrace_stub_graph
In reply to Steven RostedtFrom: "Steven Rostedt (VMware)" <[email protected]>
The ftrace_graph_stub was created and points to ftrace_stub as a way to assign the functon graph tracer function pointer to a stub function with a different prototype than what ftrace_stub has and not trigger the C verifier. The ftrace_graph_stub was created via the linker script vmlinux.lds.h. Unfortunately, powerpc already uses the name ftrace_graph_stub for its internal implementation of the function graph tracer, and even though powerpc would still build, the change via the linker script broke function tracer on powerpc from working.
By using the name ftrace_stub_graph, which does not exist anywhere else in the kernel, this should not be a problem.
--- include/asm-generic/vmlinux.lds.h | 8 ++++---- kernel/trace/fgraph.c | 6 +++--- 2 files changed, 7 insertions(+), 7 deletions(-)
include/asm-generic/vmlinux.lds.h +4 -4
@@ -112,7 +112,7 @@#ifdef CONFIG_FTRACE_MCOUNT_RECORD #ifdef CC_USING_PATCHABLE_FUNCTION_ENTRY /* -* Need to also make ftrace_graph_stub point to ftrace_stub +* Need to also make ftrace_stub_graph point to ftrace_stub * so that the same stub location may have different protocols * and not mess up with C verifiers. */
@@ -120,17 +120,17 @@ __start_mcount_loc = .; \ KEEP(*(__patchable_function_entries)) \ __stop_mcount_loc = .; \ - ftrace_graph_stub = ftrace_stub; + ftrace_stub_graph = ftrace_stub;#else #define MCOUNT_REC () . = ALIGN(8); \ __start_mcount_loc = .; \ KEEP(*(__mcount_loc)) \ __stop_mcount_loc = .; \ - ftrace_graph_stub = ftrace_stub; + ftrace_stub_graph = ftrace_stub;#endif #else # ifdef CONFIG_FUNCTION_TRACER -# define MCOUNT_REC () ftrace_graph_stub = ftrace_stub; +# define MCOUNT_REC () ftrace_stub_graph = ftrace_stub;# else # define MCOUNT_REC ()# endif
kernel/trace/fgraph.c +3 -3
@@ -336,10 +336,10 @@ int ftrace_graph_entry_stub(struct ftrace_graph_ent *trace)* Simply points to ftrace_stub, but with the proper protocol. * Defined by the linker script in linux/vmlinux.lds.h */ -extern void ftrace_graph_stub (struct ftrace_graph_ret *); +extern void ftrace_stub_graph (struct ftrace_graph_ret *);/* The callbacks that hook a function */ -trace_func_graph_ret_t ftrace_graph_return = ftrace_graph_stub; +trace_func_graph_ret_t ftrace_graph_return = ftrace_stub_graph;trace_func_graph_ent_t ftrace_graph_entry = ftrace_graph_entry_stub;static trace_func_graph_ent_t __ftrace_graph_entry = ftrace_graph_entry_stub;
@@ -619,7 +619,7 @@ void unregister_ftrace_graph(struct fgraph_ops *gops) goto out; ftrace_graph_active--; - ftrace_graph_return = ftrace_graph_stub; + ftrace_graph_return = ftrace_stub_graph; ftrace_graph_entry = ftrace_graph_entry_stub; __ftrace_graph_entry = ftrace_graph_entry_stub;ftrace_shutdown (&graph_ops,FTRACE_STOP_FUNC_RET );
Signature · 1 line
2.24.0