forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
234 lines
5.5 KiB
234 lines
5.5 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
/* |
|
* Copyright (C) 2013 Linaro Limited |
|
* Author: AKASHI Takahiro <[email protected]> |
|
* Copyright (C) 2017 Andes Technology Corporation |
|
*/ |
|
|
|
#include <linux/ftrace.h> |
|
#include <linux/uaccess.h> |
|
#include <linux/memory.h> |
|
#include <asm/cacheflush.h> |
|
#include <asm/patch.h> |
|
|
|
#ifdef CONFIG_DYNAMIC_FTRACE |
|
int ftrace_arch_code_modify_prepare(void) __acquires(&text_mutex) |
|
{ |
|
mutex_lock(&text_mutex); |
|
return 0; |
|
} |
|
|
|
int ftrace_arch_code_modify_post_process(void) __releases(&text_mutex) |
|
{ |
|
mutex_unlock(&text_mutex); |
|
return 0; |
|
} |
|
|
|
static int ftrace_check_current_call(unsigned long hook_pos, |
|
unsigned int *expected) |
|
{ |
|
unsigned int replaced[2]; |
|
unsigned int nops[2] = {NOP4, NOP4}; |
|
|
|
/* we expect nops at the hook position */ |
|
if (!expected) |
|
expected = nops; |
|
|
|
/* |
|
* Read the text we want to modify; |
|
* return must be -EFAULT on read error |
|
*/ |
|
if (copy_from_kernel_nofault(replaced, (void *)hook_pos, |
|
MCOUNT_INSN_SIZE)) |
|
return -EFAULT; |
|
|
|
/* |
|
* Make sure it is what we expect it to be; |
|
* return must be -EINVAL on failed comparison |
|
*/ |
|
if (memcmp(expected, replaced, sizeof(replaced))) { |
|
pr_err("%p: expected (%08x %08x) but got (%08x %08x)\n", |
|
(void *)hook_pos, expected[0], expected[1], replaced[0], |
|
replaced[1]); |
|
return -EINVAL; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static int __ftrace_modify_call(unsigned long hook_pos, unsigned long target, |
|
bool enable) |
|
{ |
|
unsigned int call[2]; |
|
unsigned int nops[2] = {NOP4, NOP4}; |
|
|
|
make_call(hook_pos, target, call); |
|
|
|
/* Replace the auipc-jalr pair at once. Return -EPERM on write error. */ |
|
if (patch_text_nosync |
|
((void *)hook_pos, enable ? call : nops, MCOUNT_INSN_SIZE)) |
|
return -EPERM; |
|
|
|
return 0; |
|
} |
|
|
|
/* |
|
* Put 5 instructions with 16 bytes at the front of function within |
|
* patchable function entry nops' area. |
|
* |
|
* 0: REG_S ra, -SZREG(sp) |
|
* 1: auipc ra, 0x? |
|
* 2: jalr -?(ra) |
|
* 3: REG_L ra, -SZREG(sp) |
|
* |
|
* So the opcodes is: |
|
* 0: 0xfe113c23 (sd)/0xfe112e23 (sw) |
|
* 1: 0x???????? -> auipc |
|
* 2: 0x???????? -> jalr |
|
* 3: 0xff813083 (ld)/0xffc12083 (lw) |
|
*/ |
|
#if __riscv_xlen == 64 |
|
#define INSN0 0xfe113c23 |
|
#define INSN3 0xff813083 |
|
#elif __riscv_xlen == 32 |
|
#define INSN0 0xfe112e23 |
|
#define INSN3 0xffc12083 |
|
#endif |
|
|
|
#define FUNC_ENTRY_SIZE 16 |
|
#define FUNC_ENTRY_JMP 4 |
|
|
|
int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr) |
|
{ |
|
unsigned int call[4] = {INSN0, 0, 0, INSN3}; |
|
unsigned long target = addr; |
|
unsigned long caller = rec->ip + FUNC_ENTRY_JMP; |
|
|
|
call[1] = to_auipc_insn((unsigned int)(target - caller)); |
|
call[2] = to_jalr_insn((unsigned int)(target - caller)); |
|
|
|
if (patch_text_nosync((void *)rec->ip, call, FUNC_ENTRY_SIZE)) |
|
return -EPERM; |
|
|
|
return 0; |
|
} |
|
|
|
int ftrace_make_nop(struct module *mod, struct dyn_ftrace *rec, |
|
unsigned long addr) |
|
{ |
|
unsigned int nops[4] = {NOP4, NOP4, NOP4, NOP4}; |
|
|
|
if (patch_text_nosync((void *)rec->ip, nops, FUNC_ENTRY_SIZE)) |
|
return -EPERM; |
|
|
|
return 0; |
|
} |
|
|
|
|
|
/* |
|
* This is called early on, and isn't wrapped by |
|
* ftrace_arch_code_modify_{prepare,post_process}() and therefor doesn't hold |
|
* text_mutex, which triggers a lockdep failure. SMP isn't running so we could |
|
* just directly poke the text, but it's simpler to just take the lock |
|
* ourselves. |
|
*/ |
|
int ftrace_init_nop(struct module *mod, struct dyn_ftrace *rec) |
|
{ |
|
int out; |
|
|
|
ftrace_arch_code_modify_prepare(); |
|
out = ftrace_make_nop(mod, rec, MCOUNT_ADDR); |
|
ftrace_arch_code_modify_post_process(); |
|
|
|
return out; |
|
} |
|
|
|
int ftrace_update_ftrace_func(ftrace_func_t func) |
|
{ |
|
int ret = __ftrace_modify_call((unsigned long)&ftrace_call, |
|
(unsigned long)func, true); |
|
if (!ret) { |
|
ret = __ftrace_modify_call((unsigned long)&ftrace_regs_call, |
|
(unsigned long)func, true); |
|
} |
|
|
|
return ret; |
|
} |
|
|
|
int __init ftrace_dyn_arch_init(void) |
|
{ |
|
return 0; |
|
} |
|
#endif |
|
|
|
#ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS |
|
int ftrace_modify_call(struct dyn_ftrace *rec, unsigned long old_addr, |
|
unsigned long addr) |
|
{ |
|
unsigned int call[2]; |
|
unsigned long caller = rec->ip + FUNC_ENTRY_JMP; |
|
int ret; |
|
|
|
make_call(caller, old_addr, call); |
|
ret = ftrace_check_current_call(caller, call); |
|
|
|
if (ret) |
|
return ret; |
|
|
|
return __ftrace_modify_call(caller, addr, true); |
|
} |
|
#endif |
|
|
|
#ifdef CONFIG_FUNCTION_GRAPH_TRACER |
|
/* |
|
* Most of this function is copied from arm64. |
|
*/ |
|
void prepare_ftrace_return(unsigned long *parent, unsigned long self_addr, |
|
unsigned long frame_pointer) |
|
{ |
|
unsigned long return_hooker = (unsigned long)&return_to_handler; |
|
unsigned long old; |
|
|
|
if (unlikely(atomic_read(¤t->tracing_graph_pause))) |
|
return; |
|
|
|
/* |
|
* We don't suffer access faults, so no extra fault-recovery assembly |
|
* is needed here. |
|
*/ |
|
old = *parent; |
|
|
|
if (!function_graph_enter(old, self_addr, frame_pointer, parent)) |
|
*parent = return_hooker; |
|
} |
|
|
|
#ifdef CONFIG_DYNAMIC_FTRACE |
|
extern void ftrace_graph_call(void); |
|
extern void ftrace_graph_regs_call(void); |
|
int ftrace_enable_ftrace_graph_caller(void) |
|
{ |
|
int ret; |
|
|
|
ret = __ftrace_modify_call((unsigned long)&ftrace_graph_call, |
|
(unsigned long)&prepare_ftrace_return, true); |
|
if (ret) |
|
return ret; |
|
|
|
return __ftrace_modify_call((unsigned long)&ftrace_graph_regs_call, |
|
(unsigned long)&prepare_ftrace_return, true); |
|
} |
|
|
|
int ftrace_disable_ftrace_graph_caller(void) |
|
{ |
|
int ret; |
|
|
|
ret = __ftrace_modify_call((unsigned long)&ftrace_graph_call, |
|
(unsigned long)&prepare_ftrace_return, false); |
|
if (ret) |
|
return ret; |
|
|
|
return __ftrace_modify_call((unsigned long)&ftrace_graph_regs_call, |
|
(unsigned long)&prepare_ftrace_return, false); |
|
} |
|
#endif /* CONFIG_DYNAMIC_FTRACE */ |
|
#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
|
|
|