tracing: Updates for 6.5
Subsystems (9)
Steven Rostedt
maintainercover tracing: Updates for 6.5
git://git.kernel.org/pub/scm/linux/kernel/git/trace/linux-trace.git
trace/for-next
Head SHA1: 513f25cdf82cec8eb98b111dc0570116562391e0
Azeem Shaikh (1):
tracing/boot: Replace strlcpy with strscpy
Daniel Bristot de Oliveira (3):
tracing/osnoise: Switch from PF_NO_SETAFFINITY to migrate_disable tracing/osnoise: Skip running osnoise if all instances are off tracing/timerlat: Add user-space interface
Donglin Peng (7):
function_graph: Support recording and printing the return value of function
tracing: Add documentation for funcgraph-retval and funcgraph-retval-hex
arm64: ftrace: Enable HAVE_FUNCTION_GRAPH_RETVAL
x86/ftrace: Enable HAVE_FUNCTION_GRAPH_RETVAL
LoongArch: ftrace: Enable HAVE_FUNCTION_GRAPH_RETVAL selftests/ftrace: Add funcgraph-retval test case
riscv: ftrace: Enable HAVE_FUNCTION_GRAPH_RETVAL
Jiri Olsa (1):
ftrace: Show all functions with addresses in available_filter_functions_addrs
Steven Rostedt (Google) (1):
fgraph: Add declaration of "struct fgraph_ret_regs"
----
Documentation/trace/ftrace.rst | 132 ++++++ Documentation/trace/timerlat-tracer.rst | 78 ++++ arch/arm64/Kconfig | 1 + arch/arm64/include/asm/ftrace.h | 22 + arch/arm64/kernel/asm-offsets.c | 13 + arch/arm64/kernel/entry-ftrace.S | 27 +- arch/loongarch/Kconfig | 1 + arch/loongarch/include/asm/ftrace.h | 22 + arch/loongarch/kernel/asm-offsets.c | 15 +- arch/loongarch/kernel/mcount.S | 14 +- arch/loongarch/kernel/mcount_dyn.S | 15 +- arch/riscv/Kconfig | 1 + arch/riscv/include/asm/ftrace.h | 21 + arch/riscv/kernel/mcount.S | 7 +- arch/x86/Kconfig | 1 + arch/x86/include/asm/ftrace.h | 20 + arch/x86/kernel/ftrace_32.S | 8 +- arch/x86/kernel/ftrace_64.S | 7 +- include/linux/ftrace.h | 4 + kernel/trace/Kconfig | 15 + kernel/trace/fgraph.c | 26 +- kernel/trace/ftrace.c | 37 ++ kernel/trace/trace.h | 2 + kernel/trace/trace_boot.c | 8 +- kernel/trace/trace_entries.h | 26 ++ kernel/trace/trace_functions_graph.c | 93 +++- kernel/trace/trace_osnoise.c | 477 ++++++++++++++++++++- kernel/trace/trace_output.c | 4 +- .../ftrace/test.d/ftrace/fgraph-retval.tc | 44 ++ 29 files changed, 1079 insertions(+), 62 deletions(-) create mode 100644 tools/testing/selftests/ftrace/test.d/ftrace/fgraph-retval.tc
Steven Rostedt
maintainerPATCH 2/13 function_graph: Support recording and printing the return value of function
From: Donglin Peng <[email protected]>
Analyzing system call failures with the function_graph tracer can be a time-consuming process, particularly when locating the kernel function that first returns an error in the trace logs. This change aims to simplify the process by recording the function return value to the 'retval' member of 'ftrace_graph_ret' and printing it when outputting the trace log.
We have introduced new trace options: funcgraph-retval and funcgraph-retval-hex. The former controls whether to display the return value, while the latter controls the display format.
Please note that even if a function's return type is void, a return value will still be printed. You can simply ignore it.
This patch only establishes the fundamental infrastructure. Subsequent patches will make this feature available on some commonly used processor architectures.
Here is an example:
I attempted to attach the demo process to a cpu cgroup, but it failed:
echo pidof demo > /sys/fs/cgroup/cpu/test/tasks
-bash: echo: write error: Invalid argument
The strace logs indicate that the write system call returned -EINVAL(-22):
...write(1, "273\n", 4) = -1 EINVAL (Invalid argument)
...
To capture trace logs during a write system call, use the following commands:
cd /sys/kernel/debug/tracing/
echo 0 > tracing_on
echo > trace
echo *sys_write > set_graph_function
echo *spin* > set_graph_notrace
echo *rcu* >> set_graph_notrace
echo *alloc* >> set_graph_notrace
echo preempt* >> set_graph_notrace
echo kfree* >> set_graph_notrace
echo $$ > set_ftrace_pid
echo function_graph > current_tracer
echo 1 > options/funcgraph-retval
echo 0 > options/funcgraph-retval-hex
echo 1 > tracing_on
echo pidof demo > /sys/fs/cgroup/cpu/test/tasks
echo 0 > tracing_on
cat trace > ~/trace.log
To locate the root cause, search for error code -22 directly in the file trace.log and identify the first function that returned -22. Once you have identified this function, examine its code to determine the root cause.
For example, in the trace log below, cpu_cgroup_can_attach returned -22 first, so we can focus our analysis on this function to identify the root cause.
...
1) | cgroup_migrate() {
1) 0.651 us | cgroup_migrate_add_task(); /* = 0xffff93fcfd346c00 */
1) | cgroup_migrate_execute() {
1) | cpu_cgroup_can_attach() {
1) | cgroup_taskset_first() {
1) 0.732 us | cgroup_taskset_next(); /* = 0xffff93fc8fb20000 */
1) 1.232 us | } /* cgroup_taskset_first = 0xffff93fc8fb20000 */
1) 0.380 us | sched_rt_can_attach(); /* = 0x0 */
1) 2.335 us | } /* cpu_cgroup_can_attach = -22 */
1) 4.369 us | } /* cgroup_migrate_execute = -22 */
1) 7.143 us | } /* cgroup_migrate = -22 */...
--- include/linux/ftrace.h | 3 + kernel/trace/Kconfig | 15 +++++ kernel/trace/fgraph.c | 23 ++++++- kernel/trace/trace.h | 2 + kernel/trace/trace_entries.h | 26 ++++++++ kernel/trace/trace_functions_graph.c | 93 +++++++++++++++++++++++++--- 6 files changed, 151 insertions(+), 11 deletions(-)
include/linux/ftrace.h +3 -0
@@ -1018,6 +1018,9 @@ struct ftrace_graph_ent {*/ struct ftrace_graph_ret {unsigned long func;/* Current function */ +#ifdef CONFIG_FUNCTION_GRAPH_RETVAL +unsigned long retval; +#endif int depth;/* Number of functions that overran the depth limit for current task */ unsigned int overrun;
kernel/trace/Kconfig +15 -0
@@ -31,6 +31,9 @@ config HAVE_FUNCTION_GRAPH_TRACER help See Documentation/trace/ftrace-design.rst +config HAVE_FUNCTION_GRAPH_RETVAL + bool + config HAVE_DYNAMIC_FTRACE bool help
@@ -227,6 +230,18 @@ config FUNCTION_GRAPH_TRACER the return value. This is done by setting the current return address on the current task structure into a stack of calls. +config FUNCTION_GRAPH_RETVAL + bool "Kernel Function Graph Return Value" + depends on HAVE_FUNCTION_GRAPH_RETVAL + depends on FUNCTION_GRAPH_TRACER + default n + help + Support recording and printing the function return value when + using function graph tracer. It can be helpful to locate functions + that return errors. This feature is off by default, and you can + enable it via the trace option funcgraph-retval. + See Documentation/trace/ftrace.rst + config DYNAMIC_FTRACE bool "enable/disable function tracing dynamically" depends on FUNCTION_TRACER
kernel/trace/fgraph.c +22 -1
@@ -243,12 +243,16 @@ struct fgraph_ret_regs;* Send the trace to the ring-buffer. * @return the original return address. */ -unsigned long ftrace_return_to_handler (unsigned long frame_pointer) +static unsigned long __ftrace_return_to_handler (struct fgraph_ret_regs *ret_regs, +unsigned long frame_pointer) {struct ftrace_graph_ret trace;unsigned long ret;ftrace_pop_return_trace (&trace, &ret, frame_pointer); +#ifdef CONFIG_FUNCTION_GRAPH_RETVAL + trace.retval =fgraph_ret_regs_return_value (ret_regs); +#endif trace.rettime =trace_clock_local ();ftrace_graph_return (&trace);/*
@@ -269,6 +273,23 @@ unsigned long ftrace_return_to_handler(unsigned long frame_pointer)return ret; } +/* +* After all architecures have selected HAVE_FUNCTION_GRAPH_RETVAL, we can +* leave only ftrace_return_to_handler(ret_regs). +*/ +#ifdef CONFIG_HAVE_FUNCTION_GRAPH_RETVAL +unsigned long ftrace_return_to_handler (struct fgraph_ret_regs *ret_regs) +{ +return __ftrace_return_to_handler (ret_regs, +fgraph_ret_regs_frame_pointer (ret_regs)); +} +#else +unsigned long ftrace_return_to_handler (unsigned long frame_pointer) +{ +return __ftrace_return_to_handler (NULL , frame_pointer); +} +#endif +/** * ftrace_graph_get_ret_stack - return the entry of the shadow stack * @task: The task to read the shadow stack from
kernel/trace/trace.h +2 -0
@@ -832,6 +832,8 @@ static __always_inline bool ftrace_hash_empty(struct ftrace_hash *hash)#define TRACE_GRAPH_PRINT_TAIL 0x100#define TRACE_GRAPH_SLEEP_TIME 0x200#define TRACE_GRAPH_GRAPH_TIME 0x400 +#define TRACE_GRAPH_PRINT_RETVAL 0x800 +#define TRACE_GRAPH_PRINT_RETVAL_HEX 0x1000#define TRACE_GRAPH_PRINT_FILL_SHIFT 28#define TRACE_GRAPH_PRINT_FILL_MASK (0x3 << TRACE_GRAPH_PRINT_FILL_SHIFT)
kernel/trace/trace_entries.h +26 -0
@@ -86,6 +86,30 @@ FTRACE_ENTRY_PACKED(funcgraph_entry, ftrace_graph_ent_entry, );/* Function return entry */ +#ifdef CONFIG_FUNCTION_GRAPH_RETVAL + +FTRACE_ENTRY_PACKED (funcgraph_exit, ftrace_graph_ret_entry, + +TRACE_GRAPH_RET , + +F_STRUCT ( + __field_struct( struct ftrace_graph_ret, ret ) + __field_packed( unsigned long, ret, func ) + __field_packed( unsigned long, ret, retval ) + __field_packed( int, ret, depth ) + __field_packed( unsigned int, ret, overrun ) + __field_packed( unsigned long long, ret, calltime) + __field_packed( unsigned long long, ret, rettime ) + ), + +F_printk ("<-- %ps (%d) (start: %llx end: %llx) over: %d retval: %lx" , + (void *)__entry->func, __entry->depth, + __entry->calltime, __entry->rettime, + __entry->depth, __entry->retval) +); + +#else + FTRACE_ENTRY_PACKED(funcgraph_exit, ftrace_graph_ret_entry, TRACE_GRAPH_RET,
@@ -105,6 +129,8 @@ FTRACE_ENTRY_PACKED(funcgraph_exit, ftrace_graph_ret_entry, __entry->depth) ); +#endif +/* * Context switch trace entry - which task (and prio) we switched from/to: *
kernel/trace/trace_functions_graph.c +83 -10
118 lines not on this page · raw message
Signature · 1 line
2.39.2
Steven Rostedt
maintainerPATCH 3/13 tracing: Add documentation for funcgraph-retval and funcgraph-retval-hex
In reply to Steven RostedtFrom: Donglin Peng <[email protected]>
Add documentation for the two newly introduced options for the function_graph tracer. The funcgraph-retval option is used to control whether or not to display the return value, while the funcgraph-retval-hex option is used to control the display format of the return value.
--- Documentation/trace/ftrace.rst | 126 +++++++++++++++++++++++++++++++++ 1 file changed, 126 insertions(+)
Documentation/trace/ftrace.rst +126 -0
@@ -1359,6 +1359,19 @@ Options for function_graph tracer: only a closing curly bracket "}" is displayed for the return of a function. + funcgraph-retval + When set, the return value of each traced function + will be printed after an equal sign "=". By default + this is off. + + funcgraph-retval-hex + When set, the return value will always be printed + in hexadecimal format. If the option is not set and + the return value is an error code, it will be printed + in signed decimal format; otherwise it will also be + printed in hexadecimal format. By default, this option + is off. + sleep-time When running function graph tracer, to include the time a task schedules out in its function.
@@ -2704,6 +2717,119 @@ It is default disabled. 0) 1.757 us | } /* kmem_cache_free() */ 0) 2.861 us | } /* putname() */ +The return value of each traced function can be displayed after +an equal sign "=". When encountering system call failures, it +can be verfy helpful to quickly locate the function that first +returns an error code. + + - hide: echo nofuncgraph-retval > trace_options + - show: echo funcgraph-retval > trace_options + + Example with funcgraph-retval:: + + 1) | cgroup_migrate() { + 1) 0.651 us | cgroup_migrate_add_task(); /* = 0xffff93fcfd346c00 */ + 1) | cgroup_migrate_execute() { + 1) | cpu_cgroup_can_attach() { + 1) | cgroup_taskset_first() { + 1) 0.732 us | cgroup_taskset_next(); /* = 0xffff93fc8fb20000 */ + 1) 1.232 us | } /* cgroup_taskset_first = 0xffff93fc8fb20000 */ + 1) 0.380 us | sched_rt_can_attach(); /* = 0x0 */ + 1) 2.335 us | } /* cpu_cgroup_can_attach = -22 */ + 1) 4.369 us | } /* cgroup_migrate_execute = -22 */ + 1) 7.143 us | } /* cgroup_migrate = -22 */ + +The above example shows that the function cpu_cgroup_can_attach +returned the error code -22 firstly, then we can read the code +of this function to get the root cause. + +When the option funcgraph-retval-hex is not set, the return value can +be displayed in a smart way. Specifically, if it is an error code, +it will be printed in signed decimal format, otherwise it will +printed in hexadecimal format. + + - smart: echo nofuncgraph-retval-hex > trace_options + - hexadecimal: echo funcgraph-retval-hex > trace_options + + Example with funcgraph-retval-hex:: + + 1) | cgroup_migrate() { + 1) 0.651 us | cgroup_migrate_add_task(); /* = 0xffff93fcfd346c00 */ + 1) | cgroup_migrate_execute() { + 1) | cpu_cgroup_can_attach() { + 1) | cgroup_taskset_first() { + 1) 0.732 us | cgroup_taskset_next(); /* = 0xffff93fc8fb20000 */ + 1) 1.232 us | } /* cgroup_taskset_first = 0xffff93fc8fb20000 */ + 1) 0.380 us | sched_rt_can_attach(); /* = 0x0 */ + 1) 2.335 us | } /* cpu_cgroup_can_attach = 0xffffffea */ + 1) 4.369 us | } /* cgroup_migrate_execute = 0xffffffea */ + 1) 7.143 us | } /* cgroup_migrate = 0xffffffea */ + +At present, there are some limitations when using the funcgraph-retval +option, and these limitations will be eliminated in the future: + +- Even if the function return type is void, a return value will still + be printed, and you can just ignore it. + +- Even if return values are stored in multiple registers, only the + value contained in the first register will be recorded and printed. + To illustrate, in the x86 architecture, eax and edx are used to store + a 64-bit return value, with the lower 32 bits saved in eax and the + upper 32 bits saved in edx. However, only the value stored in eax + will be recorded and printed. + +- In certain procedure call standards, such as arm64's AAPCS64, when a + type is smaller than a GPR, it is the responsibility of the consumer + to perform the narrowing, and the upper bits may contain UNKNOWN values. + Therefore, it is advisable to check the code for such cases. For instance, + when using a u8 in a 64-bit GPR, bits [63:8] may contain arbitrary values, + especially when larger types are truncated, whether explicitly or implicitly. + Here are some specific cases to illustrate this point: + + **Case One**:: + + The function narrow_to_u8 is defined as follows:: + + u8 narrow_to_u8(u64 val) + { + // implicitly truncated + return val; + } + + It may be compiled to:: + + narrow_to_u8: + < ... ftrace instrumentation ... > + RET + + If you pass 0x123456789abcdef to this function and want to narrow it, + it may be recorded as 0x123456789abcdef instead of 0xef. + + **Case Two**:: + + The function error_if_not_4g_aligned is defined as follows:: + + int error_if_not_4g_aligned(u64 val) + { + if (val & GENMASK(31, 0)) + return -EINVAL; + + return 0; + } + + It could be compiled to:: + + error_if_not_4g_aligned: + CBNZ w0, .Lnot_aligned + RET // bits [31:0] are zero, bits + // [63:32] are UNKNOWN + .Lnot_aligned: + MOV x0, #-EINVAL + RET + + When passing 0x2_0000_0000 to it, the return value may be recorded as + 0x2_0000_0000 instead of 0. + You can put some comments on specific functions by using trace_printk() For example, if you want to put a comment inside the __might_sleep() function, you just have to include
Signature · 1 line
2.39.2
Steven Rostedt
maintainerPATCH 4/13 arm64: ftrace: Enable HAVE_FUNCTION_GRAPH_RETVAL
In reply to Steven RostedtFrom: Donglin Peng <[email protected]>
The previous patch ("function_graph: Support recording and printing the return value of function") has laid the groundwork for the for the funcgraph-retval, and this modification makes it available on the ARM64 platform.
We introduce a new structure called fgraph_ret_regs for the ARM64 platform to hold return registers and the frame pointer. We then fill its content in the return_to_handler and pass its address to the function ftrace_return_to_handler to record the return value.
--- arch/arm64/Kconfig | 1 + arch/arm64/include/asm/ftrace.h | 22 ++++++++++++++++++++++ arch/arm64/kernel/asm-offsets.c | 13 +++++++++++++ arch/arm64/kernel/entry-ftrace.S | 27 ++++++++++++++------------- 4 files changed, 50 insertions(+), 13 deletions(-)
arch/arm64/Kconfig +1 -0
@@ -201,6 +201,7 @@ config ARM64 select HAVE_FTRACE_MCOUNT_RECORD select HAVE_FUNCTION_TRACER select HAVE_FUNCTION_ERROR_INJECTION + select HAVE_FUNCTION_GRAPH_RETVAL if HAVE_FUNCTION_GRAPH_TRACER select HAVE_FUNCTION_GRAPH_TRACER select HAVE_GCC_PLUGINS select HAVE_HW_BREAKPOINT if PERF_EVENTS
arch/arm64/include/asm/ftrace.h +22 -0
@@ -192,4 +192,26 @@ static inline bool arch_syscall_match_sym_name(const char *sym, }#endif /* ifndef __ASSEMBLY__ */ +#ifndef __ASSEMBLY__ +#ifdef CONFIG_FUNCTION_GRAPH_TRACER +struct fgraph_ret_regs { +/* x0 - x7 */ +unsigned long regs[8 ]; + +unsigned long fp; +unsigned long __unused; +}; + +static inline unsigned long fgraph_ret_regs_return_value (struct fgraph_ret_regs *ret_regs) +{ +return ret_regs->regs[0 ]; +} + +static inline unsigned long fgraph_ret_regs_frame_pointer (struct fgraph_ret_regs *ret_regs) +{ +return ret_regs->fp; +} +#endif /* ifdef CONFIG_FUNCTION_GRAPH_TRACER */ +#endif +#endif /* __ASM_FTRACE_H */
arch/arm64/kernel/asm-offsets.c +13 -0
@@ -200,6 +200,19 @@ int main(void)#endif #ifdef CONFIG_FUNCTION_TRACER DEFINE (FTRACE_OPS_FUNC , offsetof(struct ftrace_ops , func)); +#endif +BLANK (); +#ifdef CONFIG_FUNCTION_GRAPH_TRACER + DEFINE(FGRET_REGS_X0, offsetof(struct fgraph_ret_regs, regs[0])); + DEFINE(FGRET_REGS_X1, offsetof(struct fgraph_ret_regs, regs[1])); + DEFINE(FGRET_REGS_X2, offsetof(struct fgraph_ret_regs, regs[2])); + DEFINE(FGRET_REGS_X3, offsetof(struct fgraph_ret_regs, regs[3])); + DEFINE(FGRET_REGS_X4, offsetof(struct fgraph_ret_regs, regs[4])); + DEFINE(FGRET_REGS_X5, offsetof(struct fgraph_ret_regs, regs[5])); + DEFINE(FGRET_REGS_X6, offsetof(struct fgraph_ret_regs, regs[6])); + DEFINE(FGRET_REGS_X7, offsetof(struct fgraph_ret_regs, regs[7])); +DEFINE (FGRET_REGS_FP , offsetof(struct fgraph_ret_regs , fp)); +DEFINE (FGRET_REGS_SIZE ,sizeof (struct fgraph_ret_regs ));#ifdef CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS DEFINE (FTRACE_OPS_DIRECT_CALL , offsetof(struct ftrace_ops , direct_call));#endif
arch/arm64/kernel/entry-ftrace.S +14 -13
@@ -330,22 +330,23 @@ SYM_FUNC_END(ftrace_stub_graph) */ SYM_CODE_START(return_to_handler) /* save return value regs */ - sub sp, sp, #64 - stp x0, x1, [sp] - stp x2, x3, [sp, #16] - stp x4, x5, [sp, #32] - stp x6, x7, [sp, #48] + sub sp, sp, #FGRET_REGS_SIZE + stp x0, x1, [sp, #FGRET_REGS_X0] + stp x2, x3, [sp, #FGRET_REGS_X2] + stp x4, x5, [sp, #FGRET_REGS_X4] + stp x6, x7, [sp, #FGRET_REGS_X6] + str x29, [sp, #FGRET_REGS_FP] // parent's fp - mov x0, x29 // parent's fp - bl ftrace_return_to_handler// addr = ftrace_return_to_hander(fp); - mov x30, x0 // restore the original return address + mov x0, sp + bl ftrace_return_to_handler // addr = ftrace_return_to_hander(regs); + mov x30, x0 // restore the original return address /* restore return value regs */ - ldp x0, x1, [sp] - ldp x2, x3, [sp, #16] - ldp x4, x5, [sp, #32] - ldp x6, x7, [sp, #48] - add sp, sp, #64 + ldp x0, x1, [sp, #FGRET_REGS_X0] + ldp x2, x3, [sp, #FGRET_REGS_X2] + ldp x4, x5, [sp, #FGRET_REGS_X4] + ldp x6, x7, [sp, #FGRET_REGS_X6] + add sp, sp, #FGRET_REGS_SIZE ret SYM_CODE_END(return_to_handler)
Signature · 1 line
2.39.2
Steven Rostedt
maintainerPATCH 5/13 x86/ftrace: Enable HAVE_FUNCTION_GRAPH_RETVAL
In reply to Steven RostedtFrom: Donglin Peng <[email protected]>
The previous patch ("function_graph: Support recording and printing the return value of function") has laid the groundwork for the for the funcgraph-retval, and this modification makes it available on the x86 platform.
We introduce a new structure called fgraph_ret_regs for the x86 platform to hold return registers and the frame pointer. We then fill its content in the return_to_handler and pass its address to the function ftrace_return_to_handler to record the return value.
--- arch/x86/Kconfig | 1 + arch/x86/include/asm/ftrace.h | 20 ++++++++++++++++++++ arch/x86/kernel/ftrace_32.S | 8 +++++--- arch/x86/kernel/ftrace_64.S | 7 ++++--- 4 files changed, 30 insertions(+), 6 deletions(-)
arch/x86/Kconfig +1 -0
@@ -216,6 +216,7 @@ config X86 select HAVE_FAST_GUP select HAVE_FENTRY if X86_64 || DYNAMIC_FTRACE select HAVE_FTRACE_MCOUNT_RECORD + select HAVE_FUNCTION_GRAPH_RETVAL if HAVE_FUNCTION_GRAPH_TRACER select HAVE_FUNCTION_GRAPH_TRACER if X86_32 || (X86_64 && DYNAMIC_FTRACE) select HAVE_FUNCTION_TRACER select HAVE_GCC_PLUGINS
arch/x86/include/asm/ftrace.h +20 -0
@@ -147,4 +147,24 @@ static inline bool arch_trace_is_compat_syscall(struct pt_regs *regs)#endif /* !COMPILE_OFFSETS */ #endif /* !__ASSEMBLY__ */ +#ifndef __ASSEMBLY__ +#ifdef CONFIG_FUNCTION_GRAPH_TRACER +struct fgraph_ret_regs { +unsigned long ax; +unsigned long dx; +unsigned long bp; +}; + +static inline unsigned long fgraph_ret_regs_return_value (struct fgraph_ret_regs *ret_regs) +{ +return ret_regs->ax; +} + +static inline unsigned long fgraph_ret_regs_frame_pointer (struct fgraph_ret_regs *ret_regs) +{ +return ret_regs->bp; +} +#endif /* ifdef CONFIG_FUNCTION_GRAPH_TRACER */ +#endif +#endif /* _ASM_X86_FTRACE_H */
arch/x86/kernel/ftrace_32.S +5 -3
@@ -187,12 +187,14 @@ SYM_CODE_END(ftrace_graph_caller) .globl return_to_handler return_to_handler: - pushl %eax + pushl $0 pushl %edx - movl $0, %eax + pushl %eax + movl %esp, %eax call ftrace_return_to_handler movl %eax, %ecx - popl %edx popl %eax + popl %edx + addl $4, %esp # skip ebp JMP_NOSPEC ecx #endif
arch/x86/kernel/ftrace_64.S +4 -3
@@ -348,12 +348,13 @@ STACK_FRAME_NON_STANDARD_FP(__fentry__) SYM_CODE_START(return_to_handler) UNWIND_HINT_UNDEFINED ANNOTATE_NOENDBR - subq $16, %rsp + subq $24, %rsp /* Save the return values */ movq %rax, (%rsp) movq %rdx, 8(%rsp) - movq %rbp, %rdi + movq %rbp, 16(%rsp) + movq %rsp, %rdi call ftrace_return_to_handler
@@ -361,7 +362,7 @@ SYM_CODE_START(return_to_handler) movq 8(%rsp), %rdx movq (%rsp), %rax - addq $16, %rsp + addq $24, %rsp /* * Jump back to the old return address. This cannot be JMP_NOSPEC rdi * since IBT would demand that contain ENDBR, which simply isn't so for
Signature · 1 line
2.39.2
Steven Rostedt
maintainerPATCH 6/13 LoongArch: ftrace: Enable HAVE_FUNCTION_GRAPH_RETVAL
In reply to Steven RostedtFrom: Donglin Peng <[email protected]>
The previous patch ("function_graph: Support recording and printing the return value of function") has laid the groundwork for the for the funcgraph-retval, and this modification makes it available on the LoongArch platform.
We introduce a new structure called fgraph_ret_regs for the LoongArch platform to hold return registers and the frame pointer. We then fill its content in the return_to_handler and pass its address to the function ftrace_return_to_handler to record the return value.
--- arch/loongarch/Kconfig | 1 + arch/loongarch/include/asm/ftrace.h | 22 ++++++++++++++++++++++ arch/loongarch/kernel/asm-offsets.c | 15 ++++++++++++++- arch/loongarch/kernel/mcount.S | 14 ++++++++------ arch/loongarch/kernel/mcount_dyn.S | 15 ++++++++------- 5 files changed, 53 insertions(+), 14 deletions(-)
arch/loongarch/Kconfig +1 -0
@@ -103,6 +103,7 @@ config LOONGARCH select HAVE_FTRACE_MCOUNT_RECORD select HAVE_FUNCTION_ARG_ACCESS_API select HAVE_FUNCTION_ERROR_INJECTION + select HAVE_FUNCTION_GRAPH_RETVAL if HAVE_FUNCTION_GRAPH_TRACER select HAVE_FUNCTION_GRAPH_TRACER select HAVE_FUNCTION_TRACER select HAVE_GENERIC_VDSO
arch/loongarch/include/asm/ftrace.h +22 -0
@@ -100,4 +100,26 @@ __arch_ftrace_set_direct_caller(struct pt_regs *regs, unsigned long addr)#endif /* CONFIG_FUNCTION_TRACER */ +#ifndef __ASSEMBLY__ +#ifdef CONFIG_FUNCTION_GRAPH_TRACER +struct fgraph_ret_regs { +/* a0 - a1 */ +unsigned long regs[2 ]; + +unsigned long fp; +unsigned long __unused; +}; + +static inline unsigned long fgraph_ret_regs_return_value (struct fgraph_ret_regs *ret_regs) +{ +return ret_regs->regs[0 ]; +} + +static inline unsigned long fgraph_ret_regs_frame_pointer (struct fgraph_ret_regs *ret_regs) +{ +return ret_regs->fp; +} +#endif /* ifdef CONFIG_FUNCTION_GRAPH_TRACER */ +#endif +#endif /* _ASM_LOONGARCH_FTRACE_H */
arch/loongarch/kernel/asm-offsets.c +14 -1
@@ -12,6 +12,7 @@#include <asm/cpu-info.h> #include <asm/ptrace.h> #include <asm/processor.h> +#include <asm/ftrace.h> void output_ptreg_defines (void ) {
@@ -264,7 +265,7 @@ void output_smpboot_defines(void)#ifdef CONFIG_HIBERNATION void output_pbe_defines (void ) { -COMMENT (" Linux struct pbe offsets. " ); +COMMENT ("Linux struct pbe offsets." );OFFSET (PBE_ADDRESS , pbe, address);OFFSET (PBE_ORIG_ADDRESS , pbe, orig_address);OFFSET (PBE_NEXT , pbe, next);
@@ -272,3 +273,15 @@ void output_pbe_defines(void) BLANK(); }#endif + +#ifdef CONFIG_FUNCTION_GRAPH_TRACER +void output_fgraph_ret_regs_defines (void ) +{ +COMMENT ("LoongArch fgraph_ret_regs offsets." ); +OFFSET (FGRET_REGS_A0 , fgraph_ret_regs, regs[0 ]); +OFFSET (FGRET_REGS_A1 , fgraph_ret_regs, regs[1 ]); +OFFSET (FGRET_REGS_FP , fgraph_ret_regs, fp); +DEFINE (FGRET_REGS_SIZE ,sizeof (struct fgraph_ret_regs )); +BLANK (); +} +#endif
arch/loongarch/kernel/mcount.S +8 -6
@@ -79,18 +79,20 @@ SYM_FUNC_START(ftrace_graph_caller) SYM_FUNC_END(ftrace_graph_caller) SYM_FUNC_START(return_to_handler) - PTR_ADDI sp, sp, -2 * SZREG - PTR_S a0, sp, 0 - PTR_S a1, sp, SZREG + PTR_ADDI sp, sp, -FGRET_REGS_SIZE + PTR_S a0, sp, FGRET_REGS_A0 + PTR_S a1, sp, FGRET_REGS_A1 + PTR_S zero, sp, FGRET_REGS_FP + move a0, sp bl ftrace_return_to_handler /* Restore the real parent address: a0 -> ra */ move ra, a0 - PTR_L a0, sp, 0 - PTR_L a1, sp, SZREG - PTR_ADDI sp, sp, 2 * SZREG + PTR_L a0, sp, FGRET_REGS_A0 + PTR_L a1, sp, FGRET_REGS_A1 + PTR_ADDI sp, sp, FGRET_REGS_SIZE jr ra SYM_FUNC_END(return_to_handler) #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
arch/loongarch/kernel/mcount_dyn.S +8 -7
@@ -136,18 +136,19 @@ SYM_CODE_END(ftrace_graph_caller) SYM_CODE_START(return_to_handler) /* Save return value regs */ - PTR_ADDI sp, sp, -2 * SZREG - PTR_S a0, sp, 0 - PTR_S a1, sp, SZREG + PTR_ADDI sp, sp, -FGRET_REGS_SIZE + PTR_S a0, sp, FGRET_REGS_A0 + PTR_S a1, sp, FGRET_REGS_A1 + PTR_S zero, sp, FGRET_REGS_FP - move a0, zero + move a0, sp bl ftrace_return_to_handler move ra, a0 /* Restore return value regs */ - PTR_L a0, sp, 0 - PTR_L a1, sp, SZREG - PTR_ADDI sp, sp, 2 * SZREG + PTR_L a0, sp, FGRET_REGS_A0 + PTR_L a1, sp, FGRET_REGS_A1 + PTR_ADDI sp, sp, FGRET_REGS_SIZE jr ra SYM_CODE_END(return_to_handler)
Signature · 1 line
2.39.2
Steven Rostedt
maintainerPATCH 7/13 selftests/ftrace: Add funcgraph-retval test case
In reply to Steven RostedtFrom: Donglin Peng <[email protected]>
Add a test case for the funcgraph-retval and funcgraph-retval-hex trace options.
--- .../ftrace/test.d/ftrace/fgraph-retval.tc | 44 +++++++++++++++++++ 1 file changed, 44 insertions(+) create mode 100644 tools/testing/selftests/ftrace/test.d/ftrace/fgraph-retval.tc
tools/testing/selftests/ftrace/test.d/ftrace/fgraph-retval.tc new file +44 -0
@@ -0,0 +1,44 @@ +#!/bin/sh +# SPDX-License-Identifier: GPL-2.0 +# description: ftrace - function graph print function return value +# requires: options/funcgraph-retval options/funcgraph-retval-hex function_graph:tracer + +# Make sure that funcgraph-retval works + +fail() { # msg + echo $1 + exit_fail +} + +disable_tracing +clear_trace + +# get self PID, can not use $$, because it is PPID +read PID _ < /proc/self/stat + +[ -f set_ftrace_filter ] && echo proc_reg_write > set_ftrace_filter +[ -f set_ftrace_pid ] && echo ${PID} > set_ftrace_pid +echo function_graph > current_tracer +echo 1 > options/funcgraph-retval + +set +e +enable_tracing +echo > /proc/interrupts +disable_tracing +set -e + +: "Test printing the error code in signed decimal format" +echo 0 > options/funcgraph-retval-hex +count=`cat trace | grep 'proc_reg_write' | grep '= -5' | wc -l` +if [ $count -eq 0 ]; then + fail "Return value can not be printed in signed decimal format" +fi + +: "Test printing the error code in hexadecimal format" +echo 1 > options/funcgraph-retval-hex +count=`cat trace | grep 'proc_reg_write' | grep 'fffffffb' | wc -l` +if [ $count -eq 0 ]; then + fail "Return value can not be printed in hexadecimal format" +fi + +exit 0
Signature · 1 line
2.39.2
Steven Rostedt
maintainerPATCH 8/13 ftrace: Show all functions with addresses in available_filter_functions_addrs
In reply to Steven RostedtFrom: Jiri Olsa <[email protected]>
Adding new available_filter_functions_addrs file that shows all available functions (same as available_filter_functions) together with addresses, like:
# cat available_filter_functions_addrs | head ffffffff81000770 __traceiter_initcall_level ffffffff810007c0 __traceiter_initcall_start ffffffff81000810 __traceiter_initcall_finish ffffffff81000860 trace_initcall_finish_cb ...
Note displayed address is the patch-site address and can differ from /proc/kallsyms address.
It's useful to have address avilable for traceable symbols, so we don't need to allways cross check kallsyms with available_filter_functions (or the other way around) and have all the data in single file.
For backwards compatibility reasons we can't change the existing available_filter_functions file output, but we need to add new file.
The problem is that we need to do 2 passes:
- through available_filter_functions and find out if the function is traceable
- through /proc/kallsyms to get the address for traceable function
Having available_filter_functions symbols together with addresses allow us to skip the kallsyms step and we are ok with the address in available_filter_functions_addr not being the function entry, because kprobe_multi uses fprobe and that handles both entry and patch-site address properly.
We have 2 interfaces how to create kprobe_multi link:
a) passing symbols to kernel
1) user gathers symbols and need to ensure that they are trace-able -> pass through available_filter_functions file
2) kernel takes those symbols and translates them to addresses through kallsyms api
3) addresses are passed to fprobe/ftrace through:
register_fprobe_ips
-> ftrace_set_filter_ips
b) passing addresses to kernel
1) user gathers symbols and needs to ensure that they are trace-able -> pass through available_filter_functions file
2) user takes those symbols and translates them to addresses through /proc/kallsyms
3) addresses are passed to the kernel and kernel calls:
register_fprobe_ips
-> ftrace_set_filter_ips
The new available_filter_functions_addrs file helps us with option b), because we can make 'b 1' and 'b 2' in one step - while filtering traceable functions, we get the address directly.
--- Documentation/trace/ftrace.rst | 6 ++++++ include/linux/ftrace.h | 1 + kernel/trace/ftrace.c | 37 ++++++++++++++++++++++++++++++++++ 3 files changed, 44 insertions(+)
Documentation/trace/ftrace.rst +6 -0
@@ -324,6 +324,12 @@ of ftrace. Here is a list of some of the key files: "set_graph_function", or "set_graph_notrace". (See the section "dynamic ftrace" below for more details.) + available_filter_functions_addrs: + + Similar to available_filter_functions, but with address displayed + for each function. The displayed address is the patch-site address + and can differ from /proc/kallsyms address. + dyn_ftrace_total_info: This file is for debugging purposes. The number of functions that
include/linux/ftrace.h +1 -0
@@ -633,6 +633,7 @@ enum {FTRACE_ITER_MOD = (1 <<5 ),FTRACE_ITER_ENABLED = (1 <<6 ),FTRACE_ITER_TOUCHED = (1 <<7 ), + FTRACE_ITER_ADDRS = (1 << 8), };void arch_ftrace_update_code (int command);
kernel/trace/ftrace.c +37 -0
@@ -3861,6 +3861,9 @@ static int t_show(struct seq_file *m, void *v)if (!rec)return 0 ; +if (iter->flags &FTRACE_ITER_ADDRS ) +seq_printf (m,"%lx " , rec->ip); +if (print_rec (m, rec->ip)) {/* This should only happen when a rec is disabled */ WARN_ON_ONCE (!(rec->flags &FTRACE_FL_DISABLED ));
@@ -3996,6 +3999,30 @@ ftrace_touched_open(struct inode *inode, struct file *file)return 0 ; } +static int +ftrace_avail_addrs_open (struct inode *inode,struct file *file) +{ +struct ftrace_iterator *iter; +int ret; + + ret =security_locked_down (LOCKDOWN_TRACEFS ); +if (ret) +return ret; + +if (unlikely (ftrace_disabled)) +return -ENODEV ; + + iter =__seq_open_private (file, &show_ftrace_seq_ops,sizeof (*iter)); +if (!iter) +return -ENOMEM ; + + iter->pg = ftrace_pages_start; + iter->flags =FTRACE_ITER_ADDRS ; + iter->ops = &global_ops; + +return 0 ; +} +/** * ftrace_regex_open - initialize function tracer filter files * @ops: The ftrace_ops that hold the hash filters
@@ -5916,6 +5943,13 @@ static const struct file_operations ftrace_touched_fops = { .release = seq_release_private, }; +static const struct file_operations ftrace_avail_addrs_fops = { + .open = ftrace_avail_addrs_open, + .read = seq_read, + .llseek = seq_lseek, + .release = seq_release_private, +}; +static const struct file_operations ftrace_filter_fops = { .open = ftrace_filter_open, .read = seq_read,
@@ -6377,6 +6411,9 @@ static __init int ftrace_init_dyn_tracefs(struct dentry *d_tracer)trace_create_file ("available_filter_functions" ,TRACE_MODE_READ , d_tracer,NULL , &ftrace_avail_fops); +trace_create_file ("available_filter_functions_addrs" ,TRACE_MODE_READ , + d_tracer,NULL , &ftrace_avail_addrs_fops); +trace_create_file ("enabled_functions" ,TRACE_MODE_READ , d_tracer,NULL , &ftrace_enabled_fops);
Signature · 1 line
2.39.2
Re: [for-next][PATCH 08/13] ftrace: Show all functions with addresses in available_filter_functions_addrs
Quoted 171 lines · Steven Rostedt
From: Jiri Olsa <[email protected]>
Adding new
available_filter_functions_addrsfile that shows all available functions (same asavailable_filter_functions) together with addresses, like:# cat available_filter_functions_addrs | head ffffffff81000770 __traceiter_initcall_level ffffffff810007c0 __traceiter_initcall_start ffffffff81000810 __traceiter_initcall_finish ffffffff81000860 trace_initcall_finish_cb ...Note displayed address is the patch-site address and can differ from
/proc/kallsymsaddress.It's useful to have address avilable for traceable symbols, so we don't need to allways cross check kallsyms with
available_filter_functions(or the other way around) and have all the data in single file.For backwards compatibility reasons we can't change the existing
available_filter_functionsfile output, but we need to add new file.The problem is that we need to do 2 passes:
- through
available_filter_functionsand find out if the function is traceable
- through/proc/kallsymsto get the address for traceable functionHaving
available_filter_functionssymbols together with addresses allow us to skip the kallsyms step and we are ok with the address inavailable_filter_functions_addrnot being the function entry, becausekprobe_multiuses fprobe and that handles both entry and patch-site address properly.We have 2 interfaces how to create
kprobe_multilink:a) passing symbols to kernel
1) user gathers symbols and need to ensure that they are trace-able -> pass through
available_filter_functionsfile2) kernel takes those symbols and translates them to addresses through kallsyms api
3) addresses are passed to fprobe/ftrace through:
register_fprobe_ips
->ftrace_set_filter_ipsb) passing addresses to kernel
1) user gathers symbols and needs to ensure that they are trace-able -> pass through
available_filter_functionsfile2) user takes those symbols and translates them to addresses through
/proc/kallsyms3) addresses are passed to the kernel and kernel calls:
register_fprobe_ips
->ftrace_set_filter_ipsThe new
available_filter_functions_addrsfile helps us with option b), because we can make 'b 1' and 'b 2' in one step - while filtering traceable functions, we get the address directly.Cc Masami Hiramatsu <[email protected]>Cc Mark Rutland <[email protected]>Cc Andrii Nakryiko <[email protected]>Cc Jackie Liu <[email protected]>Suggested-by Steven Rostedt (Google) <[email protected]>Suggested-by Andrii Nakryiko <[email protected]>Signed-off-by Jiri Olsa <[email protected]>Signed-off-by Steven Rostedt (Google) <[email protected]>--- Documentation/trace/ftrace.rst | 6 ++++++ include/linux/ftrace.h | 1 + kernel/trace/ftrace.c | 37 ++++++++++++++++++++++++++++++++++ 3 files changed, 44 insertions(+)Documentation/trace/ftrace.rst +6
-0@@ -324,6 +324,12 @@ of ftrace. Here is a list of some of the key files: "set_graph_function", or "set_graph_notrace". (See the section "dynamic ftrace" below for more details.) + available_filter_functions_addrs: + + Similar to available_filter_functions, but with address displayed + for each function. The displayed address is the patch-site address + and can differ from /proc/kallsyms address. + dyn_ftrace_total_info: This file is for debugging purposes. The number of functions thatinclude/linux/ftrace.h +1
-0@@ -633,6 +633,7 @@ enum {FTRACE_ITER_MOD = (1 <<5 ),FTRACE_ITER_ENABLED = (1 <<6 ),FTRACE_ITER_TOUCHED = (1 <<7 ), + FTRACE_ITER_ADDRS = (1 << 8), };void arch_ftrace_update_code (int command);kernel/trace/ftrace.c +34
-0@@ -3861,6 +3861,9 @@ static int t_show(struct seq_file *m, void *v)if (!rec)return 0 ; +if (iter->flags &FTRACE_ITER_ADDRS ) +seq_printf (m,"%lx " , rec->ip); +if (print_rec (m, rec->ip)) {/* This should only happen when a rec is disabled */ WARN_ON_ONCE (!(rec->flags &FTRACE_FL_DISABLED ));@@ -3996,6 +3999,30 @@ ftrace_touched_open(struct inode *inode, struct file *file)return 0 ; } +static int +ftrace_avail_addrs_open (struct inode *inode,struct file *file) +{ +struct ftrace_iterator *iter; +int ret; + + ret =security_locked_down (LOCKDOWN_TRACEFS ); +if (ret) +return ret; + +if (unlikely (ftrace_disabled)) +return -ENODEV ; + + iter =__seq_open_private (file, &show_ftrace_seq_ops,sizeof (*iter)); +if (!iter) +return -ENOMEM ; + + iter->pg = ftrace_pages_start; + iter->flags =FTRACE_ITER_ADDRS ; + iter->ops = &global_ops; + +return 0 ; +} +/** * ftrace_regex_open - initialize function tracer filter files * @ops: The ftrace_ops that hold the hash filters @@ -5916,6 +5943,13 @@ static const struct file_operations ftrace_touched_fops = { .release = seq_release_private, }; +static const struct file_operations ftrace_avail_addrs_fops = { + .open = ftrace_avail_addrs_open, + .read = seq_read, + .llseek = seq_lseek, + .release = seq_release_private, +}; +static const struct file_operations ftrace_filter_fops = { .open = ftrace_filter_open, .read = seq_read,
kernel/trace/ftrace.c static __init int ftrace_init_dyn_tracefs(struct dentry *d_tracer) · line 6416
Quoted 6 lines
kernel/trace/ftrace.c +3
-0@@ -6377,6 +6411,9 @@ static __init int ftrace_init_dyn_tracefs(struct dentry *d_tracer)trace_create_file ("available_filter_functions" ,TRACE_MODE_READ , d_tracer,NULL , &ftrace_avail_fops); +trace_create_file ("available_filter_functions_addrs" ,TRACE_MODE_READ , + d_tracer,NULL , &ftrace_avail_addrs_fops); +
Quoted 3 lines
kernel/trace/ftrace.c +0
-0trace_create_file ("enabled_functions" ,TRACE_MODE_READ , d_tracer,NULL , &ftrace_enabled_fops);
Steven Rostedt
maintainerPATCH 9/13 tracing/osnoise: Switch from PF_NO_SETAFFINITY to migrate_disable
In reply to Steven RostedtFrom: Daniel Bristot de Oliveira <[email protected]>
Currently, osnoise/timerlat threads run with PF_NO_SETAFFINITY set. It works well, however, cgroups do not allow PF_NO_SETAFFINITY threads to be accepted, and this creates a limitation to osnoise/timerlat.
To avoid this limitation, disable migration of the threads as soon as they start to run, and then clean the PF_NO_SETAFFINITY flag (still) used during thread creation.
If for some reason a thread migration is requested, e.g., via sched_settafinity, the tracer thread will notice and exit.
--- kernel/trace/trace_osnoise.c | 68 ++++++++++++++++++++++++++++++++++++ 1 file changed, 68 insertions(+)
kernel/trace/trace_osnoise.c +68 -0
@@ -1545,6 +1545,39 @@ static void osnoise_sleep(void) } } +/* +* osnoise_migration_pending - checks if the task needs to migrate +* +* osnoise/timerlat threads are per-cpu. If there is a pending request to +* migrate the thread away from the current CPU, something bad has happened. +* Play the good citizen and leave. +* +* Returns 0 if it is safe to continue, 1 otherwise. +*/ +static inline int osnoise_migration_pending (void ) +{ +if (!current->migration_pending) +return 0 ; + +/* +* If migration is pending, there is a task waiting for the +* tracer to enable migration. The tracer does not allow migration, +* thus: taint and leave to unblock the blocked thread. +*/ +osnoise_taint ("migration requested to osnoise threads, leaving." ); + +/* +* Unset this thread from the threads managed by the interface. +* The tracers are responsible for cleaning their env before +* exiting. +*/ +mutex_lock (&interface_lock); +this_cpu_osn_var ()->kthread =NULL ; +mutex_unlock (&interface_lock); + +return 1 ; +} +/* * osnoise_main - The osnoise detection kernel thread *
@@ -1553,12 +1586,29 @@ static void osnoise_sleep(void)*/ static int osnoise_main (void *data) { +unsigned long flags; + +/* +* This thread was created pinned to the CPU using PF_NO_SETAFFINITY. +* The problem is that cgroup does not allow PF_NO_SETAFFINITY thread. +* +* To work around this limitation, disable migration and remove the +* flag. +*/ +migrate_disable (); +raw_spin_lock_irqsave (¤t->pi_lock, flags); + current->flags &= ~(PF_NO_SETAFFINITY ); +raw_spin_unlock_irqrestore (¤t->pi_lock, flags);while (!kthread_should_stop ()) { +if (osnoise_migration_pending ()) +break ; +run_osnoise ();osnoise_sleep (); } +migrate_enable ();return 0 ; }
@@ -1706,6 +1756,7 @@ static int timerlat_main(void *data)struct timerlat_variables *tlat =this_cpu_tmr_var ();struct timerlat_sample s;struct sched_param sp; +unsigned long flags;u64 now, diff;/*
@@ -1714,6 +1765,18 @@ static int timerlat_main(void *data) sp.sched_priority =DEFAULT_TIMERLAT_PRIO ;sched_setscheduler_nocheck (current,SCHED_FIFO , &sp); +/* +* This thread was created pinned to the CPU using PF_NO_SETAFFINITY. +* The problem is that cgroup does not allow PF_NO_SETAFFINITY thread. +* +* To work around this limitation, disable migration and remove the +* flag. +*/ +migrate_disable (); +raw_spin_lock_irqsave (¤t->pi_lock, flags); + current->flags &= ~(PF_NO_SETAFFINITY ); +raw_spin_unlock_irqrestore (¤t->pi_lock, flags); + tlat->count =0 ; tlat->tracing_thread = false;
@@ -1731,6 +1794,7 @@ static int timerlat_main(void *data) osn_var->sampling =1 ;while (!kthread_should_stop ()) { + now =ktime_to_ns (hrtimer_cb_get_time (&tlat->timer)); diff = now - tlat->abs_period;
@@ -1749,10 +1813,14 @@ static int timerlat_main(void *data)if (time_to_us (diff) >= osnoise_data.stop_tracing_total)osnoise_stop_tracing (); +if (osnoise_migration_pending ()) +break ; + wait_next_period(tlat); }hrtimer_cancel (&tlat->timer); +migrate_enable ();return 0 ; }#else /* CONFIG_TIMERLAT_TRACER */
Signature · 1 line
2.39.2
Steven Rostedt
maintainerPATCH 10/13 tracing/osnoise: Skip running osnoise if all instances are off
In reply to Steven RostedtFrom: Daniel Bristot de Oliveira <[email protected]>
In the case of all tracing instances being off, sleep for the entire period.
Q: Why not kill all threads so?
A: It is valid and useful to start the threads with tracing off.
For example, rtla disables tracing, starts the tracer, applies the scheduling setup to the threads, e.g., sched priority and cgroup, and then begin tracing with all set.
Skipping the period helps to speed up rtla setup and save the trace after a stop tracing.
--- kernel/trace/trace_osnoise.c | 31 ++++++++++++++++++++++++++++--- 1 file changed, 28 insertions(+), 3 deletions(-)
kernel/trace/trace_osnoise.c +28 -3
@@ -1285,6 +1285,22 @@ static __always_inline void osnoise_stop_tracing(void)rcu_read_unlock (); } +/* +* osnoise_has_tracing_on - Check if there is at least one instance on +*/ +static __always_inline int osnoise_has_tracing_on(void) +{ +struct osnoise_instance *inst; +int trace_is_on =0 ; + +rcu_read_lock (); +list_for_each_entry_rcu (inst, &osnoise_instances, list) + trace_is_on +=tracer_tracing_is_on (inst->tr); +rcu_read_unlock (); + +return trace_is_on; +} +/* * notify_new_max_latency - Notify a new max latency via fsnotify interface. */
@@ -1517,13 +1533,16 @@ static struct cpumask save_cpumask;/* * osnoise_sleep - sleep until the next period */ -static void osnoise_sleep (void ) +static void osnoise_sleep (bool skip_period) {u64 interval;ktime_t wake_time;mutex_lock (&interface_lock); - interval = osnoise_data.sample_period - osnoise_data.sample_runtime; +if (skip_period) + interval = osnoise_data.sample_period; +else + interval = osnoise_data.sample_period - osnoise_data.sample_runtime;mutex_unlock (&interface_lock);/*
@@ -1604,8 +1623,14 @@ static int osnoise_main(void *data)if (osnoise_migration_pending ())break ; +/* skip a period if tracing is off on all instances */ +if (!osnoise_has_tracing_on ()) { +osnoise_sleep (true); +continue ; + } +run_osnoise (); -osnoise_sleep (); +osnoise_sleep (false); }migrate_enable ();
Signature · 1 line
2.39.2
Steven Rostedt
maintainerPATCH 11/13 tracing/timerlat: Add user-space interface
In reply to Steven RostedtFrom: Daniel Bristot de Oliveira <[email protected]>
Going a step further, we propose a way to use any user-space workload as the task waiting for the timerlat timer. This is done via a per-CPU file named osnoise/cpu$id/timerlat_fd file.
The tracef_fd allows a task to open at a time. When a task reads the file, the timerlat timer is armed for future osnoise/timerlat_period_us time. When the timer fires, it prints the IRQ latency and
wakes up the user-space thread waiting in the timerlat_fd.
The thread then starts to run, executes the timerlat measurement, prints the thread scheduling latency and returns to user-space.
When the thread rereads the timerlat_fd, the tracer will print the user-ret(urn) latency, which is an additional metric.
This additional metric is also traced by the tracer and can be used, for example of measuring the context switch overhead from kernel-to-user and user-to-kernel, or the response time for an arbitrary execution in user-space.
The tracer supports one thread per CPU, the thread must be pinned to the CPU, and it cannot migrate while holding the timerlat_fd. The reason is that the tracer is per CPU (nothing prohibits the tracer from allowing migrations in the future). The tracer monitors the migration of the thread and disables the tracer if detected.
The timerlat_fd is only available for opening/reading when timerlat tracer is enabled, and NO_OSNOISE_WORKLOAD is set.
The simplest way to activate this feature from user-space is:
-------------------------------- %< ----------------------------------- int main(void)
{
char buffer[1024];
int timerlat_fd;
int retval;
long cpu = 0; /* place in CPU 0 */
cpu_set_t set;
CPU_ZERO(&set);
CPU_SET(cpu, &set);
if (sched_setaffinity(gettid(), sizeof(set), &set) == -1)
return 1;
snprintf(buffer, sizeof(buffer),
"/sys/kernel/tracing/osnoise/per_cpu/cpu%ld/timerlat_fd",
cpu);
timerlat_fd = open(buffer, O_RDONLY);
if (timerlat_fd < 0) {
printf("error opening %s: %s\n", buffer, strerror(errno));
exit(1);
}
for (;;) {
retval = read(timerlat_fd, buffer, 1024);
if (retval < 0)
break;
}
close(timerlat_fd);
exit(0);
}-------------------------------- >% -----------------------------------
When disabling timerlat, if there is a workload holding the timerlat_fd, the SIGKILL will be sent to the thread.
--- Documentation/trace/timerlat-tracer.rst | 78 +++++ kernel/trace/trace_osnoise.c | 378 +++++++++++++++++++++++- kernel/trace/trace_output.c | 4 +- 3 files changed, 455 insertions(+), 5 deletions(-)
Documentation/trace/timerlat-tracer.rst +78 -0
@@ -180,3 +180,81 @@ dummy_load_1ms_pd_init, which had the following code (on purpose):: return 0; } + +User-space interface +--------------------------- + +Timerlat allows user-space threads to use timerlat infra-structure to +measure scheduling latency. This interface is accessible via a per-CPU +file descriptor inside $tracing_dir/osnoise/per_cpu/cpu$ID/timerlat_fd. + +This interface is accessible under the following conditions: + + - timerlat tracer is enable + - osnoise workload option is set to NO_OSNOISE_WORKLOAD + - The user-space thread is affined to a single processor + - The thread opens the file associated with its single processor + - Only one thread can access the file at a time + +The open() syscall will fail if any of these conditions are not met. +After opening the file descriptor, the user space can read from it. + +The read() system call will run a timerlat code that will arm the +timer in the future and wait for it as the regular kernel thread does. + +When the timer IRQ fires, the timerlat IRQ will execute, report the +IRQ latency and wake up the thread waiting in the read. The thread will be +scheduled and report the thread latency via tracer - as for the kernel +thread. + +The difference from the in-kernel timerlat is that, instead of re-arming +the timer, timerlat will return to the read() system call. At this point, +the user can run any code. + +If the application rereads the file timerlat file descriptor, the tracer +will report the return from user-space latency, which is the total +latency. If this is the end of the work, it can be interpreted as the +response time for the request. + +After reporting the total latency, timerlat will restart the cycle, arm +a timer, and go to sleep for the following activation. + +If at any time one of the conditions is broken, e.g., the thread migrates +while in user space, or the timerlat tracer is disabled, the SIG_KILL +signal will be sent to the user-space thread. + +Here is an basic example of user-space code for timerlat:: + + int main(void) + { + char buffer[1024]; + int timerlat_fd; + int retval; + long cpu = 0; /* place in CPU 0 */ + cpu_set_t set; + + CPU_ZERO(&set); + CPU_SET(cpu, &set); + + if (sched_setaffinity(gettid(), sizeof(set), &set) == -1) + return 1; + + snprintf(buffer, sizeof(buffer), + "/sys/kernel/tracing/osnoise/per_cpu/cpu%ld/timerlat_fd", + cpu); + + timerlat_fd = open(buffer, O_RDONLY); + if (timerlat_fd < 0) { + printf("error opening %s: %s\n", buffer, strerror(errno)); + exit(1); + } + + for (;;) { + retval = read(timerlat_fd, buffer, 1024); + if (retval < 0) + break; + } + + close(timerlat_fd); + exit(0); + }
kernel/trace/trace_osnoise.c +374 -4
469 lines not on this page · raw message
kernel/trace/trace_output.c +3 -1
@@ -1446,6 +1446,8 @@ static struct trace_event trace_osnoise_event = { };/* TRACE_TIMERLAT */ + +static char *timerlat_lat_context[] = {"irq" ,"thread" ,"user-ret" };static enum print_line_t trace_timerlat_print (struct trace_iterator *iter,int flags,struct trace_event *event)
@@ -1458,7 +1460,7 @@ trace_timerlat_print(struct trace_iterator *iter, int flags,trace_seq_printf (s,"#%-5u context %6s timer_latency %9llu ns\n" , field->seqnum, - field->context ?"thread" :"irq" , + timerlat_lat_context[field->context], field->timer_latency);return trace_handle_return (s);
Signature · 1 line
2.39.2
Steven Rostedt
maintainerPATCH 12/13 tracing/boot: Replace strlcpy with strscpy
In reply to Steven RostedtFrom: Azeem Shaikh <[email protected]>
strlcpy() reads the entire source buffer first. This read may exceed the destination size limit. This is both inefficient and can lead to linear read overflows if a source string is not NUL-terminated [1]. In an effort to remove strlcpy() completely [2], replace strlcpy() here with strscpy().
Direct replacement is safe here since return value of -E2BIG is used to check for truncation instead of sizeof(dest).
[1] https://www.kernel.org/doc/html/latest/process/deprecated.html#strlcpy
[2] https://github.com/KSPP/linux/issues/89
--- kernel/trace/trace_boot.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
kernel/trace/trace_boot.c +4 -4
@@ -31,7 +31,7 @@ trace_boot_set_instance_options(struct trace_array *tr, struct xbc_node *node)/* Common ftrace options */ xbc_node_for_each_array_value (node,"options" , anode, p) { -if (strlcpy (buf, p,ARRAY_SIZE (buf)) >=ARRAY_SIZE (buf)) { +if (strscpy (buf, p,ARRAY_SIZE (buf)) == -E2BIG ) {pr_err ("String is too long: %s\n" , p);continue ; }
@@ -87,7 +87,7 @@ trace_boot_enable_events(struct trace_array *tr, struct xbc_node *node)const char *p;xbc_node_for_each_array_value (node,"events" , anode, p) { -if (strlcpy (buf, p,ARRAY_SIZE (buf)) >=ARRAY_SIZE (buf)) { +if (strscpy (buf, p,ARRAY_SIZE (buf)) == -E2BIG ) {pr_err ("String is too long: %s\n" , p);continue ; }
@@ -486,7 +486,7 @@ trace_boot_init_one_event(struct trace_array *tr, struct xbc_node *gnode, p =xbc_node_find_value (enode,"filter" ,NULL );if (p && *p !='\0' ) { -if (strlcpy (buf, p,ARRAY_SIZE (buf)) >=ARRAY_SIZE (buf)) +if (strscpy (buf, p,ARRAY_SIZE (buf)) == -E2BIG )pr_err ("filter string is too long: %s\n" , p);else if (apply_event_filter (file, buf) <0 )pr_err ("Failed to apply filter: %s\n" , buf);
@@ -494,7 +494,7 @@ trace_boot_init_one_event(struct trace_array *tr, struct xbc_node *gnode,if (IS_ENABLED (CONFIG_HIST_TRIGGERS )) {xbc_node_for_each_array_value (enode,"actions" , anode, p) { -if (strlcpy (buf, p,ARRAY_SIZE (buf)) >=ARRAY_SIZE (buf)) +if (strscpy (buf, p,ARRAY_SIZE (buf)) == -E2BIG )pr_err ("action string is too long: %s\n" , p);else if (trigger_process_regex (file, buf) <0 )pr_err ("Failed to apply an action: %s\n" , p);
Signature · 1 line
2.39.2
Steven Rostedt
maintainerPATCH 13/13 riscv: ftrace: Enable HAVE_FUNCTION_GRAPH_RETVAL
In reply to Steven RostedtFrom: Donglin Peng <[email protected]>
The previous patch ("function_graph: Support recording and printing the return value of function") has laid the groundwork for the for the funcgraph-retval, and this modification makes it available on the RISC-V platform.
We introduce a new structure called fgraph_ret_regs for the RISC-V platform to hold return registers and the frame pointer. We then fill its content in the return_to_handler and pass its address to the function ftrace_return_to_handler to record the return value.
--- arch/riscv/Kconfig | 1 + arch/riscv/include/asm/ftrace.h | 21 +++++++++++++++++++++ arch/riscv/kernel/mcount.S | 7 +------ 3 files changed, 23 insertions(+), 6 deletions(-)
arch/riscv/Kconfig +1 -0
@@ -146,6 +146,7 @@ config RISCV select HAVE_DYNAMIC_FTRACE_WITH_REGS if HAVE_DYNAMIC_FTRACE select HAVE_FTRACE_MCOUNT_RECORD if !XIP_KERNEL select HAVE_FUNCTION_GRAPH_TRACER + select HAVE_FUNCTION_GRAPH_RETVAL if HAVE_FUNCTION_GRAPH_TRACER select HAVE_FUNCTION_TRACER if !XIP_KERNEL && !PREEMPTION config CLANG_SUPPORTS_DYNAMIC_FTRACE
arch/riscv/include/asm/ftrace.h +21 -0
@@ -111,4 +111,25 @@ int ftrace_init_nop(struct module *mod, struct dyn_ftrace *rec);#endif /* CONFIG_DYNAMIC_FTRACE */ +#ifndef __ASSEMBLY__ +#ifdef CONFIG_FUNCTION_GRAPH_TRACER +struct fgraph_ret_regs { +unsigned long a1; +unsigned long a0; +unsigned long s0; +unsigned long ra; +}; + +static inline unsigned long fgraph_ret_regs_return_value (struct fgraph_ret_regs *ret_regs) +{ +return ret_regs->a0; +} + +static inline unsigned long fgraph_ret_regs_frame_pointer (struct fgraph_ret_regs *ret_regs) +{ +return ret_regs->s0; +} +#endif /* ifdef CONFIG_FUNCTION_GRAPH_TRACER */ +#endif +#endif /* _ASM_RISCV_FTRACE_H */
arch/riscv/kernel/mcount.S +1 -6
@@ -65,13 +65,8 @@ ENTRY(return_to_handler) * So alternatively we check the *old* frame pointer position, that is, the * value stored in -16(s0) on entry, and the s0 on return. */ -#ifdef HAVE_FUNCTION_GRAPH_FP_TEST - mv t6, s0 -#endif SAVE_RET_ABI_STATE -#ifdef HAVE_FUNCTION_GRAPH_FP_TEST - mv a0, t6 -#endif + mv a0, sp call ftrace_return_to_handler mv a2, a0 RESTORE_RET_ABI_STATE
Signature · 1 line
2.39.2
A message that is not in the archive (sent off-list or not yet received): [email protected]
Steven Rostedt
maintainerRe: [for-next][PATCH 01/13] fgraph: Add declaration of "struct fgraph_ret_regs"
Sending manually, as quilt mail didn't acknowledge some character in this email, and it was rejected by lkml as wrong mime type.
-- Steve
Quoted 33 lines · On Wed, 21 Jun 2023 12:29:24 -0400 Steven Rostedt <[email protected]> wrote:
From: "Steven Rostedt (Google)" <[email protected]>
In final testing of:
https://patchwork.kernel.org/project/linux-trace-kernel/patch/1fc502712c981e0e6742185ba242992170ac9da8.1680954589.git.pengdonglin@sangfor.com.cn/
"function_graph: Support recording and printing the return value of function"The test failed due to a new warning found in the build:
kernel/trace/fgraph.c:243:56: warning: ‘struct fgraph_ret_regs’ declared inside parameter list will not be visible outside of this definition or declarationInstead of asking to send another patch series, just add it and then apply the updates.
Signed-off-by Steven Rostedt (Google) <[email protected]>--- kernel/trace/fgraph.c | 3 +++ 1 file changed, 3 insertions(+)kernel/trace/fgraph.c +3
-0@@ -236,6 +236,9 @@ static struct notifier_block ftrace_suspend_notifier = { .notifier_call = ftrace_suspend_notifier_call, }; +/* fgraph_ret_regs is not defined without CONFIG_FUNCTION_GRAPH_RETVAL */ +struct fgraph_ret_regs ; +/* * Send the trace to the ring-buffer. * @return the original return address.