ftrace: Add ftrace_get_symaddr to convert fentry_ip to symaddr

This introduces ftrace_get_symaddr() which tries to convert fentry_ip
passed by ftrace or fgraph callback to symaddr without calling
kallsyms API. It returns the symbol address or 0 if it fails to
convert it.

Cc: Alexei Starovoitov <alexei.starovoitov@gmail.com>
Cc: Florent Revest <revest@chromium.org>
Cc: Martin KaFai Lau <martin.lau@linux.dev>
Cc: bpf <bpf@vger.kernel.org>
Cc: Alexei Starovoitov <ast@kernel.org>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Alan Maguire <alan.maguire@oracle.com>
Cc: Mark Rutland <mark.rutland@arm.com>
Link: https://lore.kernel.org/173519011487.391279.5450806886342723151.stgit@devnote2
Signed-off-by: Masami Hiramatsu (Google) <mhiramat@kernel.org>
Reported-by: kernel test robot <lkp@intel.com>
Closes: https://lore.kernel.org/oe-kbuild-all/202412061423.K79V55Hd-lkp@intel.com/
Closes: https://lore.kernel.org/oe-kbuild-all/202412061804.5VRzF14E-lkp@intel.com/
Signed-off-by: Steven Rostedt (Google) <rostedt@goodmis.org>

diff --git a/arch/arm64/include/asm/ftrace.h b/arch/arm64/include/asm/ftrace.h
index 876e88ad4119f9042d75ad838c0c5caee6a58386..bfe3ce9df19781d451cf58cd894bef409dea65af 100644 (file)
--- a/arch/arm64/include/asm/ftrace.h
+++ b/arch/arm64/include/asm/ftrace.h
@@ -52,6 +52,8 @@ extern unsigned long ftrace_graph_call;
 extern void return_to_handler(void);
 
 unsigned long ftrace_call_adjust(unsigned long addr);
+unsigned long arch_ftrace_get_symaddr(unsigned long fentry_ip);
+#define ftrace_get_symaddr(fentry_ip) arch_ftrace_get_symaddr(fentry_ip)
 
 #ifdef CONFIG_DYNAMIC_FTRACE_WITH_ARGS
 #define HAVE_ARCH_FTRACE_REGS

diff --git a/arch/arm64/kernel/ftrace.c b/arch/arm64/kernel/ftrace.c
index 570c38be833c13bc1704702039b0a49902df20eb..d7c0d023dfe5e686b75f926198c29097d078e330 100644 (file)
--- a/arch/arm64/kernel/ftrace.c
+++ b/arch/arm64/kernel/ftrace.c
@@ -143,6 +143,69 @@ unsigned long ftrace_call_adjust(unsigned long addr)
        return addr;
 }
 
+/* Convert fentry_ip to the symbol address without kallsyms */
+unsigned long arch_ftrace_get_symaddr(unsigned long fentry_ip)
+{
+       u32 insn;
+
+       /*
+        * When using patchable-function-entry without pre-function NOPS, ftrace
+        * entry is the address of the first NOP after the function entry point.
+        *
+        * The compiler has either generated:
+        *
+        * func+00:     func:   NOP             // To be patched to MOV X9, LR
+        * func+04:             NOP             // To be patched to BL <caller>
+        *
+        * Or:
+        *
+        * func-04:             BTI     C
+        * func+00:     func:   NOP             // To be patched to MOV X9, LR
+        * func+04:             NOP             // To be patched to BL <caller>
+        *
+        * The fentry_ip is the address of `BL <caller>` which is at `func + 4`
+        * bytes in either case.
+        */
+       if (!IS_ENABLED(CONFIG_DYNAMIC_FTRACE_WITH_CALL_OPS))
+               return fentry_ip - AARCH64_INSN_SIZE;
+
+       /*
+        * When using patchable-function-entry with pre-function NOPs, BTI is
+        * a bit different.
+        *
+        * func+00:     func:   NOP             // To be patched to MOV X9, LR
+        * func+04:             NOP             // To be patched to BL <caller>
+        *
+        * Or:
+        *
+        * func+00:     func:   BTI     C
+        * func+04:             NOP             // To be patched to MOV X9, LR
+        * func+08:             NOP             // To be patched to BL <caller>
+        *
+        * The fentry_ip is the address of `BL <caller>` which is at either
+        * `func + 4` or `func + 8` depends on whether there is a BTI.
+        */
+
+       /* If there is no BTI, the func address should be one instruction before. */
+       if (!IS_ENABLED(CONFIG_ARM64_BTI_KERNEL))
+               return fentry_ip - AARCH64_INSN_SIZE;
+
+       /* We want to be extra safe in case entry ip is on the page edge,
+        * but otherwise we need to avoid get_kernel_nofault()'s overhead.
+        */
+       if ((fentry_ip & ~PAGE_MASK) < AARCH64_INSN_SIZE * 2) {
+               if (get_kernel_nofault(insn, (u32 *)(fentry_ip - AARCH64_INSN_SIZE * 2)))
+                       return 0;
+       } else {
+               insn = *(u32 *)(fentry_ip - AARCH64_INSN_SIZE * 2);
+       }
+
+       if (aarch64_insn_is_bti(le32_to_cpu((__le32)insn)))
+               return fentry_ip - AARCH64_INSN_SIZE * 2;
+
+       return fentry_ip - AARCH64_INSN_SIZE;
+}
+
 /*
  * Replace a single instruction, which may be a branch or NOP.
  * If @validate == true, a replaced instruction is checked against 'old'.

diff --git a/arch/x86/include/asm/ftrace.h b/arch/x86/include/asm/ftrace.h
index cc92c99ef2760ac8ced94c11453e1253a0378a31..f9cb4d07df58fd865a237c52997803685be3c7d2 100644 (file)
--- a/arch/x86/include/asm/ftrace.h
+++ b/arch/x86/include/asm/ftrace.h
@@ -34,6 +34,27 @@ static inline unsigned long ftrace_call_adjust(unsigned long addr)
        return addr;
 }
 
+static inline unsigned long arch_ftrace_get_symaddr(unsigned long fentry_ip)
+{
+#ifdef CONFIG_X86_KERNEL_IBT
+       u32 instr;
+
+       /* We want to be extra safe in case entry ip is on the page edge,
+        * but otherwise we need to avoid get_kernel_nofault()'s overhead.
+        */
+       if ((fentry_ip & ~PAGE_MASK) < ENDBR_INSN_SIZE) {
+               if (get_kernel_nofault(instr, (u32 *)(fentry_ip - ENDBR_INSN_SIZE)))
+                       return fentry_ip;
+       } else {
+               instr = *(u32 *)(fentry_ip - ENDBR_INSN_SIZE);
+       }
+       if (is_endbr(instr))
+               fentry_ip -= ENDBR_INSN_SIZE;
+#endif
+       return fentry_ip;
+}
+#define ftrace_get_symaddr(fentry_ip)  arch_ftrace_get_symaddr(fentry_ip)
+
 #ifdef CONFIG_HAVE_DYNAMIC_FTRACE_WITH_ARGS
 
 #include <linux/ftrace_regs.h>

diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h
index 4c553fe9c0263c79aa213258048609b11c5ebec8..07092dfb21a4e9f9aafab64e61fe4e4db02a0f8b 100644 (file)
--- a/include/linux/ftrace.h
+++ b/include/linux/ftrace.h
@@ -622,6 +622,19 @@ enum {
        FTRACE_MAY_SLEEP                = (1 << 5),
 };
 
+/* Arches can override ftrace_get_symaddr() to convert fentry_ip to symaddr. */
+#ifndef ftrace_get_symaddr
+/**
+ * ftrace_get_symaddr - return the symbol address from fentry_ip
+ * @fentry_ip: the address of ftrace location
+ *
+ * Get the symbol address from @fentry_ip (fast path). If there is no fast
+ * search path, this returns 0.
+ * User may need to use kallsyms API to find the symbol address.
+ */
+#define ftrace_get_symaddr(fentry_ip) (0)
+#endif
+
 #ifdef CONFIG_DYNAMIC_FTRACE
 
 void ftrace_arch_code_modify_prepare(void);