1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) 2013 Linaro Limited 4 * Author: AKASHI Takahiro <takahiro.akashi@linaro.org> 5 * Copyright (C) 2017 Andes Technology Corporation 6 */ 7 8 #include <linux/ftrace.h> 9 #include <linux/uaccess.h> 10 #include <linux/memory.h> 11 #include <asm/cacheflush.h> 12 #include <asm/patch.h> 13 14 #ifdef CONFIG_DYNAMIC_FTRACE 15 void ftrace_arch_code_modify_prepare(void) __acquires(&text_mutex) 16 { 17 mutex_lock(&text_mutex); 18 } 19 20 void ftrace_arch_code_modify_post_process(void) __releases(&text_mutex) 21 { 22 mutex_unlock(&text_mutex); 23 } 24 25 static int ftrace_check_current_call(unsigned long hook_pos, 26 unsigned int *expected) 27 { 28 unsigned int replaced[2]; 29 unsigned int nops[2] = {NOP4, NOP4}; 30 31 /* we expect nops at the hook position */ 32 if (!expected) 33 expected = nops; 34 35 /* 36 * Read the text we want to modify; 37 * return must be -EFAULT on read error 38 */ 39 if (copy_from_kernel_nofault(replaced, (void *)hook_pos, 40 MCOUNT_INSN_SIZE)) 41 return -EFAULT; 42 43 /* 44 * Make sure it is what we expect it to be; 45 * return must be -EINVAL on failed comparison 46 */ 47 if (memcmp(expected, replaced, sizeof(replaced))) { 48 pr_err("%p: expected (%08x %08x) but got (%08x %08x)\n", 49 (void *)hook_pos, expected[0], expected[1], replaced[0], 50 replaced[1]); 51 return -EINVAL; 52 } 53 54 return 0; 55 } 56 57 static int __ftrace_modify_call(unsigned long hook_pos, unsigned long target, 58 bool enable) 59 { 60 unsigned int call[2]; 61 unsigned int nops[2] = {NOP4, NOP4}; 62 63 make_call(hook_pos, target, call); 64 65 /* Replace the auipc-jalr pair at once. Return -EPERM on write error. */ 66 if (patch_text_nosync 67 ((void *)hook_pos, enable ? call : nops, MCOUNT_INSN_SIZE)) 68 return -EPERM; 69 70 return 0; 71 } 72 73 /* 74 * Put 5 instructions with 16 bytes at the front of function within 75 * patchable function entry nops' area. 76 * 77 * 0: REG_S ra, -SZREG(sp) 78 * 1: auipc ra, 0x? 79 * 2: jalr -?(ra) 80 * 3: REG_L ra, -SZREG(sp) 81 * 82 * So the opcodes is: 83 * 0: 0xfe113c23 (sd)/0xfe112e23 (sw) 84 * 1: 0x???????? -> auipc 85 * 2: 0x???????? -> jalr 86 * 3: 0xff813083 (ld)/0xffc12083 (lw) 87 */ 88 #if __riscv_xlen == 64 89 #define INSN0 0xfe113c23 90 #define INSN3 0xff813083 91 #elif __riscv_xlen == 32 92 #define INSN0 0xfe112e23 93 #define INSN3 0xffc12083 94 #endif 95 96 #define FUNC_ENTRY_SIZE 16 97 #define FUNC_ENTRY_JMP 4 98 99 int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr) 100 { 101 unsigned int call[4] = {INSN0, 0, 0, INSN3}; 102 unsigned long target = addr; 103 unsigned long caller = rec->ip + FUNC_ENTRY_JMP; 104 105 call[1] = to_auipc_insn((unsigned int)(target - caller)); 106 call[2] = to_jalr_insn((unsigned int)(target - caller)); 107 108 if (patch_text_nosync((void *)rec->ip, call, FUNC_ENTRY_SIZE)) 109 return -EPERM; 110 111 return 0; 112 } 113 114 int ftrace_make_nop(struct module *mod, struct dyn_ftrace *rec, 115 unsigned long addr) 116 { 117 unsigned int nops[4] = {NOP4, NOP4, NOP4, NOP4}; 118 119 if (patch_text_nosync((void *)rec->ip, nops, FUNC_ENTRY_SIZE)) 120 return -EPERM; 121 122 return 0; 123 } 124 125 126 /* 127 * This is called early on, and isn't wrapped by 128 * ftrace_arch_code_modify_{prepare,post_process}() and therefor doesn't hold 129 * text_mutex, which triggers a lockdep failure. SMP isn't running so we could 130 * just directly poke the text, but it's simpler to just take the lock 131 * ourselves. 132 */ 133 int ftrace_init_nop(struct module *mod, struct dyn_ftrace *rec) 134 { 135 int out; 136 137 ftrace_arch_code_modify_prepare(); 138 out = ftrace_make_nop(mod, rec, MCOUNT_ADDR); 139 ftrace_arch_code_modify_post_process(); 140 141 return out; 142 } 143 144 int ftrace_update_ftrace_func(ftrace_func_t func) 145 { 146 int ret = __ftrace_modify_call((unsigned long)&ftrace_call, 147 (unsigned long)func, true); 148 if (!ret) { 149 ret = __ftrace_modify_call((unsigned long)&ftrace_regs_call, 150 (unsigned long)func, true); 151 } 152 153 return ret; 154 } 155 #endif 156 157 #ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS 158 int ftrace_modify_call(struct dyn_ftrace *rec, unsigned long old_addr, 159 unsigned long addr) 160 { 161 unsigned int call[2]; 162 unsigned long caller = rec->ip + FUNC_ENTRY_JMP; 163 int ret; 164 165 make_call(caller, old_addr, call); 166 ret = ftrace_check_current_call(caller, call); 167 168 if (ret) 169 return ret; 170 171 return __ftrace_modify_call(caller, addr, true); 172 } 173 #endif 174 175 #ifdef CONFIG_FUNCTION_GRAPH_TRACER 176 /* 177 * Most of this function is copied from arm64. 178 */ 179 void prepare_ftrace_return(unsigned long *parent, unsigned long self_addr, 180 unsigned long frame_pointer) 181 { 182 unsigned long return_hooker = (unsigned long)&return_to_handler; 183 unsigned long old; 184 185 if (unlikely(atomic_read(¤t->tracing_graph_pause))) 186 return; 187 188 /* 189 * We don't suffer access faults, so no extra fault-recovery assembly 190 * is needed here. 191 */ 192 old = *parent; 193 194 if (!function_graph_enter(old, self_addr, frame_pointer, parent)) 195 *parent = return_hooker; 196 } 197 198 #ifdef CONFIG_DYNAMIC_FTRACE 199 extern void ftrace_graph_call(void); 200 extern void ftrace_graph_regs_call(void); 201 int ftrace_enable_ftrace_graph_caller(void) 202 { 203 int ret; 204 205 ret = __ftrace_modify_call((unsigned long)&ftrace_graph_call, 206 (unsigned long)&prepare_ftrace_return, true); 207 if (ret) 208 return ret; 209 210 return __ftrace_modify_call((unsigned long)&ftrace_graph_regs_call, 211 (unsigned long)&prepare_ftrace_return, true); 212 } 213 214 int ftrace_disable_ftrace_graph_caller(void) 215 { 216 int ret; 217 218 ret = __ftrace_modify_call((unsigned long)&ftrace_graph_call, 219 (unsigned long)&prepare_ftrace_return, false); 220 if (ret) 221 return ret; 222 223 return __ftrace_modify_call((unsigned long)&ftrace_graph_regs_call, 224 (unsigned long)&prepare_ftrace_return, false); 225 } 226 #endif /* CONFIG_DYNAMIC_FTRACE */ 227 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */ 228