RISC-V: Don't check text_mutex during stop_machine
PATCH 1/1 RISC-V: Don't check text_mutex during stop_machine
From: Palmer Dabbelt <[email protected]>
We're currently using stop_machine() to update ftrace, which means that the thread that takes text_mutex during ftrace_prepare() may not be the same as the thread that eventually patches the code. This isn't actually a race because the lock is still held (preventing any other concurrent accesses) and there is only one thread running during stop_machine(), but it does trigger a lockdep failure.
This patch just elides the lockdep check during stop_machine.
--
Changes since v1 [<[email protected]>]:
* Use ftrace_arch_ocde_modify_{prepare,post_process}() to set the flag. I remember having a reason I wanted the function when I wrote the v1, but it's been almost a year and I forget what that was -- maybe I was just crazy, the patch was sent at midnight.
* Fix DYNAMIC_FTRACE=n builds.
--- arch/riscv/include/asm/ftrace.h | 7 +++++++ arch/riscv/kernel/ftrace.c | 12 ++++++++++++ arch/riscv/kernel/patch.c | 10 +++++++++- 3 files changed, 28 insertions(+), 1 deletion(-)
arch/riscv/include/asm/ftrace.h +7 -0
@@ -81,8 +81,15 @@ do { \struct dyn_ftrace ;int ftrace_init_nop (struct module *mod,struct dyn_ftrace *rec);#define ftrace_init_nop ftrace_init_nop +extern int riscv_ftrace_in_stop_machine;#endif +#else /* CONFIG_DYNAMIC_FTRACE */ + +#ifndef __ASSEMBLY__ +#define riscv_ftrace_in_stop_machine 0#endif +#endif /* CONFIG_DYNAMIC_FTRACE */ +#endif /* _ASM_RISCV_FTRACE_H */
arch/riscv/kernel/ftrace.c +12 -0
@@ -11,15 +11,27 @@#include <asm/cacheflush.h> #include <asm/patch.h> +int riscv_ftrace_in_stop_machine; +#ifdef CONFIG_DYNAMIC_FTRACE int ftrace_arch_code_modify_prepare(void) __acquires(&text_mutex) {mutex_lock (&text_mutex); + +/* +* The code sequences we use for ftrace can't be patched while the +* kernel is running, so we need to use stop_machine() to modify them +* for now. This doesn't play nice with text_mutex, we use this flag +* to elide the check. +*/ + riscv_ftrace_in_stop_machine = true; +return 0 ; } int ftrace_arch_code_modify_post_process(void) __releases(&text_mutex) { + riscv_ftrace_in_stop_machine = false;mutex_unlock (&text_mutex);return 0 ; }
arch/riscv/kernel/patch.c +9 -1
@@ -11,6 +11,7 @@#include <asm/kprobes.h> #include <asm/cacheflush.h> #include <asm/fixmap.h> +#include <asm/ftrace.h> #include <asm/patch.h> struct patch_insn {
@@ -59,8 +60,15 @@ static int patch_insn_write(void *addr, const void *insn, size_t len)* Before reaching here, it was expected to lock the text_mutex * already, so we don't need to give another lock here and could * ensure that it was safe between each cores. +* +* We're currently using stop_machine() for ftrace, and while that +* ensures text_mutex is held before installing the mappings it does +* not ensure text_mutex is held by the calling thread. That's safe +* but triggers a lockdep failure, so just elide it for that specific +* case. */ -lockdep_assert_held (&text_mutex); +if (!riscv_ftrace_in_stop_machine) +lockdep_assert_held (&text_mutex);if (across_pages)patch_map (addr + len,FIX_TEXT_POKE1 );
Signature · 1 line
2.34.1
Quoted 73 lines · Palmer Dabbelt
From: Palmer Dabbelt <[email protected]>
We're currently using
stop_machine()to update ftrace, which means that the thread that takestext_mutexduringftrace_prepare()may not be the same as the thread that eventually patches the code. This isn't actually a race because the lock is still held (preventing any other concurrent accesses) and there is only one thread running duringstop_machine(), but it does trigger a lockdep failure.This patch just elides the lockdep check during
stop_machine.Fixes c15ac4fd60d5 ("riscv/ftrace: Add dynamic function tracer support")Suggested-by Steven Rostedt <[email protected]>Reported-by Changbin Du <[email protected]>Signed-off-by Palmer Dabbelt <[email protected]>Signed-off-by Palmer Dabbelt <[email protected]>--
Changes since v1 [<[email protected]>]:
* Use ftrace_arch_ocde_modify_{prepare,post_process}() to set the flag. I remember having a reason I wanted the function when I wrote the v1, but it's been almost a year and I forget what that was -- maybe I was just crazy, the patch was sent at midnight.
* Fix DYNAMIC_FTRACE=n builds.--- arch/riscv/include/asm/ftrace.h | 7 +++++++ arch/riscv/kernel/ftrace.c | 12 ++++++++++++ arch/riscv/kernel/patch.c | 10 +++++++++- 3 files changed, 28 insertions(+), 1 deletion(-)arch/riscv/include/asm/ftrace.h +7
-0@@ -81,8 +81,15 @@ do { \struct dyn_ftrace ;int ftrace_init_nop (struct module *mod,struct dyn_ftrace *rec);#define ftrace_init_nop ftrace_init_nop +extern int riscv_ftrace_in_stop_machine;#endif +#else /* CONFIG_DYNAMIC_FTRACE */ + +#ifndef __ASSEMBLY__ +#define riscv_ftrace_in_stop_machine 0#endif +#endif /* CONFIG_DYNAMIC_FTRACE */ +#endif /* _ASM_RISCV_FTRACE_H */ arch/riscv/kernel/ftrace.c +10
-0@@ -11,15 +11,27 @@#include <asm/cacheflush.h> #include <asm/patch.h> +int riscv_ftrace_in_stop_machine; +#ifdef CONFIG_DYNAMIC_FTRACE int ftrace_arch_code_modify_prepare(void) __acquires(&text_mutex) {mutex_lock (&text_mutex); + +/* +* The code sequences we use for ftrace can't be patched while the +* kernel is running, so we need to use stop_machine() to modify them +* for now. This doesn't play nice with text_mutex, we use this flag +* to elide the check. +*/ + riscv_ftrace_in_stop_machine = true;
arch/riscv/kernel/ftrace.c line 37
Quoted 10 lines
arch/riscv/kernel/ftrace.c +2
-0+return 0 ; } int ftrace_arch_code_modify_post_process(void) __releases(&text_mutex) { + riscv_ftrace_in_stop_machine = false;mutex_unlock (&text_mutex);return 0 ; }
The function ftrace_init_nop() should be updated. That's not in stop-machine context.
@@ -136,9 +124,9 @@ int ftrace_init_nop(struct module *mod, struct dyn_ftrace *rec)
{
int out;- ftrace_arch_code_modify_prepare();
+ mutex_lock(&text_mutex);
out = ftrace_make_nop(mod, rec, MCOUNT_ADDR);- ftrace_arch_code_modify_post_process();
+ mutex_unlock(&text_mutex);
Signature · 2 lines
Cheers, Changbin Du