1 /* SPDX-License-Identifier: GPL-2.0-only */ 2 /* 3 * arch/arm64/include/asm/ftrace.h 4 * 5 * Copyright (C) 2013 Linaro Limited 6 * Author: AKASHI Takahiro <takahiro.akashi@linaro.org> 7 */ 8 #ifndef __ASM_FTRACE_H 9 #define __ASM_FTRACE_H 10 11 #include <asm/insn.h> 12 13 #define HAVE_FUNCTION_GRAPH_FP_TEST 14 15 #ifdef CONFIG_DYNAMIC_FTRACE_WITH_ARGS 16 #define ARCH_SUPPORTS_FTRACE_OPS 1 17 #else 18 #define MCOUNT_ADDR ((unsigned long)_mcount) 19 #endif 20 21 /* The BL at the callsite's adjusted rec->ip */ 22 #define MCOUNT_INSN_SIZE AARCH64_INSN_SIZE 23 24 #define FTRACE_PLT_IDX 0 25 #define NR_FTRACE_PLTS 1 26 27 /* 28 * Currently, gcc tends to save the link register after the local variables 29 * on the stack. This causes the max stack tracer to report the function 30 * frame sizes for the wrong functions. By defining 31 * ARCH_FTRACE_SHIFT_STACK_TRACER, it will tell the stack tracer to expect 32 * to find the return address on the stack after the local variables have 33 * been set up. 34 * 35 * Note, this may change in the future, and we will need to deal with that 36 * if it were to happen. 37 */ 38 #define ARCH_FTRACE_SHIFT_STACK_TRACER 1 39 40 #ifndef __ASSEMBLY__ 41 #include <linux/compat.h> 42 43 extern void _mcount(unsigned long); 44 extern void *return_address(unsigned int); 45 46 struct dyn_arch_ftrace { 47 /* No extra data needed for arm64 */ 48 }; 49 50 extern unsigned long ftrace_graph_call; 51 52 extern void return_to_handler(void); 53 54 unsigned long ftrace_call_adjust(unsigned long addr); 55 unsigned long arch_ftrace_get_symaddr(unsigned long fentry_ip); 56 #define ftrace_get_symaddr(fentry_ip) arch_ftrace_get_symaddr(fentry_ip) 57 58 #ifdef CONFIG_DYNAMIC_FTRACE_WITH_ARGS 59 #define HAVE_ARCH_FTRACE_REGS 60 struct dyn_ftrace; 61 struct ftrace_ops; 62 struct ftrace_regs; 63 #define arch_ftrace_regs(fregs) ((struct __arch_ftrace_regs *)(fregs)) 64 65 #define arch_ftrace_get_regs(regs) NULL 66 67 /* 68 * Note: sizeof(struct ftrace_regs) must be a multiple of 16 to ensure correct 69 * stack alignment 70 */ 71 struct __arch_ftrace_regs { 72 /* x0 - x8 */ 73 unsigned long regs[9]; 74 75 #ifdef CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS 76 unsigned long direct_tramp; 77 #else 78 unsigned long __unused; 79 #endif 80 81 unsigned long fp; 82 unsigned long lr; 83 84 unsigned long sp; 85 unsigned long pc; 86 }; 87 88 static __always_inline unsigned long 89 ftrace_regs_get_instruction_pointer(const struct ftrace_regs *fregs) 90 { 91 return arch_ftrace_regs(fregs)->pc; 92 } 93 94 static __always_inline void 95 ftrace_regs_set_instruction_pointer(struct ftrace_regs *fregs, 96 unsigned long pc) 97 { 98 arch_ftrace_regs(fregs)->pc = pc; 99 } 100 101 static __always_inline unsigned long 102 ftrace_regs_get_stack_pointer(const struct ftrace_regs *fregs) 103 { 104 return arch_ftrace_regs(fregs)->sp; 105 } 106 107 static __always_inline unsigned long 108 ftrace_regs_get_argument(struct ftrace_regs *fregs, unsigned int n) 109 { 110 if (n < 8) 111 return arch_ftrace_regs(fregs)->regs[n]; 112 return 0; 113 } 114 115 static __always_inline unsigned long 116 ftrace_regs_get_return_value(const struct ftrace_regs *fregs) 117 { 118 return arch_ftrace_regs(fregs)->regs[0]; 119 } 120 121 static __always_inline void 122 ftrace_regs_set_return_value(struct ftrace_regs *fregs, 123 unsigned long ret) 124 { 125 arch_ftrace_regs(fregs)->regs[0] = ret; 126 } 127 128 static __always_inline void 129 ftrace_override_function_with_return(struct ftrace_regs *fregs) 130 { 131 arch_ftrace_regs(fregs)->pc = arch_ftrace_regs(fregs)->lr; 132 } 133 134 static __always_inline unsigned long 135 ftrace_regs_get_frame_pointer(const struct ftrace_regs *fregs) 136 { 137 return arch_ftrace_regs(fregs)->fp; 138 } 139 140 static __always_inline unsigned long 141 ftrace_regs_get_return_address(const struct ftrace_regs *fregs) 142 { 143 return arch_ftrace_regs(fregs)->lr; 144 } 145 146 static __always_inline struct pt_regs * 147 ftrace_partial_regs(const struct ftrace_regs *fregs, struct pt_regs *regs) 148 { 149 struct __arch_ftrace_regs *afregs = arch_ftrace_regs(fregs); 150 151 memcpy(regs->regs, afregs->regs, sizeof(afregs->regs)); 152 regs->sp = afregs->sp; 153 regs->pc = afregs->pc; 154 regs->regs[29] = afregs->fp; 155 regs->regs[30] = afregs->lr; 156 regs->pstate = PSR_MODE_EL1h; 157 return regs; 158 } 159 160 #define arch_ftrace_fill_perf_regs(fregs, _regs) do { \ 161 (_regs)->pc = arch_ftrace_regs(fregs)->pc; \ 162 (_regs)->regs[29] = arch_ftrace_regs(fregs)->fp; \ 163 (_regs)->sp = arch_ftrace_regs(fregs)->sp; \ 164 (_regs)->pstate = PSR_MODE_EL1h; \ 165 } while (0) 166 167 int ftrace_regs_query_register_offset(const char *name); 168 169 int ftrace_init_nop(struct module *mod, struct dyn_ftrace *rec); 170 #define ftrace_init_nop ftrace_init_nop 171 172 void ftrace_graph_func(unsigned long ip, unsigned long parent_ip, 173 struct ftrace_ops *op, struct ftrace_regs *fregs); 174 #define ftrace_graph_func ftrace_graph_func 175 176 #ifdef CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS 177 static inline void arch_ftrace_set_direct_caller(struct ftrace_regs *fregs, 178 unsigned long addr) 179 { 180 /* 181 * The ftrace trampoline will return to this address instead of the 182 * instrumented function. 183 */ 184 arch_ftrace_regs(fregs)->direct_tramp = addr; 185 } 186 #endif /* CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS */ 187 188 #endif 189 190 #define ftrace_return_address(n) return_address(n) 191 192 /* 193 * Because AArch32 mode does not share the same syscall table with AArch64, 194 * tracing compat syscalls may result in reporting bogus syscalls or even 195 * hang-up, so just do not trace them. 196 * See kernel/trace/trace_syscalls.c 197 * 198 * x86 code says: 199 * If the user really wants these, then they should use the 200 * raw syscall tracepoints with filtering. 201 */ 202 #define ARCH_TRACE_IGNORE_COMPAT_SYSCALLS 203 static inline bool arch_trace_is_compat_syscall(struct pt_regs *regs) 204 { 205 return is_compat_task(); 206 } 207 208 #define ARCH_HAS_SYSCALL_MATCH_SYM_NAME 209 210 static inline bool arch_syscall_match_sym_name(const char *sym, 211 const char *name) 212 { 213 /* 214 * Since all syscall functions have __arm64_ prefix, we must skip it. 215 * However, as we described above, we decided to ignore compat 216 * syscalls, so we don't care about __arm64_compat_ prefix here. 217 */ 218 return !strcmp(sym + 8, name); 219 } 220 #endif /* ifndef __ASSEMBLY__ */ 221 222 #ifndef __ASSEMBLY__ 223 #ifdef CONFIG_FUNCTION_GRAPH_TRACER 224 225 void prepare_ftrace_return(unsigned long self_addr, unsigned long *parent, 226 unsigned long frame_pointer); 227 228 #endif /* ifdef CONFIG_FUNCTION_GRAPH_TRACER */ 229 #endif 230 231 #endif /* __ASM_FTRACE_H */ 232