RISC-V Ftrace 实现原理（3）- 替换函数入口

// kernel/trace/ftrace.c ：6434

static __init int ftrace_init_dyn_tracefs(struct dentry *d_tracer){

    ftrace_create_filter_files(&global_ops, d_tracer);

}

void ftrace_create_filter_files(struct ftrace_ops *ops,
                                struct dentry *parent)
{

    trace_create_file("set_ftrace_filter", TRACE_MODE_WRITE, parent,
                          ops, &ftrace_filter_fops);
}

tracefs_create_file()
  inode->i_private = data; // global_ops
  inode->i_fop = fops; // ftrace_filter_fops

// kernel/trace/ftrace.c ：1034

struct ftrace_ops global_ops = {
        .func                           = ftrace_stub,
        .local_hash.notrace_hash        = EMPTY_HASH,
        .local_hash.filter_hash         = EMPTY_HASH,
        INIT_OPS_HASH(global_ops)
        .flags                          = FTRACE_OPS_FL_INITIALIZED |
                                          FTRACE_OPS_FL_PID,
};

// kernel/trace/ftrace.c ：5975
static const struct file_operations ftrace_filter_fops = {
        .open = ftrace_filter_open,
        .read = seq_read,
        .write = ftrace_filter_write,
        .llseek = tracing_lseek,
        .release = ftrace_regex_release,
};

// kernel/trace/ftrace.c ：3890

static int ftrace_filter_open(struct inode *inode, struct file *file)
{
        struct ftrace_ops *ops = inode->i_private;  // 取出 ops
        return ftrace_regex_open(ops,
                        FTRACE_ITER_FILTER | FTRACE_ITER_DO_PROBES,
                        inode, file);
}

int ftrace_regex_open(struct ftrace_ops *ops, int flag,
                  struct inode *inode, struct file *file)
{
        if (trace_parser_get_init(&iter->parser, FTRACE_BUFF_MAX)) // 创建 FTRACE_BUFF_MAX 大小的 parser->buffer
                goto out;

        iter->ops = ops;
        iter->flags = flag;
        iter->tr = tr;

        hash = ops->func_hash->filter_hash;

        const int size_bits = FTRACE_HASH_DEFAULT_BITS;

        iter->hash = alloc_and_copy_ftrace_hash(size_bits, hash); // 拷贝 hash

        file->private_data = iter;
}

// kernel/trace/ftrace.c ：4964

ssize_t ftrace_filter_write(struct file *file, const char __user *ubuf,
                    size_t cnt, loff_t *ppos)
{
        return ftrace_regex_write(file, ubuf, cnt, ppos, 1);
}

ftrace_regex_write(file, ubuf, cnt, ppos, 1);
  trace_get_user(parser, ubuf, cnt, ppos); // 解析用户态字符串 ubuf，存放到 parser->buffer
  ftrace_process_regex(iter, parser->buffer, parser->idx, enable); // 遍历函数入口表，找到匹配项，并记录到 iter->hash
    func_g.type = filter_parse_regex(func, len, &func_g.search, &clear_filter); // 解析目标函数到 func_g.search，用于后续的函数入口表匹配
    do_for_each_ftrace_rec(pg, rec) {  // 遍历 `ftrace_pages_start`
     if(ftrace_match_record(rec, &func_g, mod_match, exclude_mod)) // 通过 kallsyms_lookup 获取当前 rec->ip 对应的函数符号，与 func_g 进行匹配
       enter_record(hash, rec, clear_filter)  // 把当前函数更新到 iter->hash 中

// kernel/trace/ftrace.c ：1502

#define do_for_each_ftrace_rec(pg, rec)                                 \
        for (pg = ftrace_pages_start; pg; pg = pg->next) {              \
                int _____i;                                             \
                for (_____i = 0; _____i < pg->index; _____i++) {        \
                        rec = &pg->records[_____i];

#define while_for_each_ftrace_rec()             \
                }                               \
        }

// kernel/trace/ftrace.c ：1087

struct ftrace_page {
        struct ftrace_page      *next;
        struct dyn_ftrace       *records;
        int                     index;
        int                     order;
};

// include/linux/ftrace.h ：1141

struct dyn_ftrace {
        unsigned long           ip; /* address of mcount call-site */
        unsigned long           flags;
        struct dyn_arch_ftrace  arch;
};

// kernel/trace/ftrace.c ：5911

ftrace_regex_release()
 orig_hash = &iter->ops->func_hash->filter_hash // 记录之前的 hash
 filter_hash = !!(iter->flags & FTRACE_ITER_FILTER);  // 这里是 true
 ftrace_hash_move_and_update_ops(iter->ops, orig_hash, iter->hash, filter_hash);
 free_ftrace_hash(iter->hash);

// kernel/trace/ftrace.c ：4140
static int ftrace_hash_move_and_update_ops(struct ftrace_ops *ops, struct ftrace_hash **orig_hash, struct ftrace_hash *hash, int enable)
{
        struct ftrace_ops_hash old_hash_ops;
        struct ftrace_hash *old_hash;
        int ret;

        old_hash = *orig_hash;
        old_hash_ops.filter_hash = ops->func_hash->filter_hash;
        old_hash_ops.notrace_hash = ops->func_hash->notrace_hash;  // old_hash_ops 是 ops->func_hash->{filter_hash,notrace_hash} 更新前的备份，在修改代码前备份到 ops->old_hash
        ret = ftrace_hash_move(ops, enable, orig_hash, hash);
        if (!ret) {
                ftrace_ops_update_code(ops, &old_hash_ops);
                free_ftrace_hash_rcu(old_hash);
        }
        return ret;
}

// kernel/trace/ftrace.c ：1407

static int ftrace_hash_move(struct ftrace_ops *ops, int enable,struct ftrace_hash **dst, struct ftrace_hash *src){
     new_hash = __ftrace_hash_move(src);
     ret = __ftrace_hash_update_ipmodify(ops, old_hash, new_hash); // 遍历函数入口表，更新 rec->flags 的 FTRACE_FL_IPMODIFY，避免多 ftrace 用户并发修改
     ftrace_hash_rec_disable_modify(ops, enable);  // 将 old_hash 中的函数的 flags 计数减一并清空相关功能 flags
     rcu_assign_pointer(*dst, new_hash);           // 将 new_hash 覆盖到 old_hash (ops->func_hash->filter_hash)
     ftrace_hash_rec_enable_modify(ops, enable);  // 将 new_hash 中的函数的 flags 计数加一并初始化相关功能 flags
}

// kernel/trace/ftrace.c ：4109

ftrace_ops_update_code(ops, &old_hash_ops);
     ftrace_run_modify_code(op, FTRACE_UPDATE_CALLS, old_hash); // FTRACE_UPDATE_CALLS 表示执行函数入口修改

static void ftrace_run_modify_code(struct ftrace_ops *ops, int command,
                                   struct ftrace_ops_hash *old_hash)
{
        ops->flags |= FTRACE_OPS_FL_MODIFYING;
        ops->old_hash.filter_hash = old_hash->filter_hash;
        ops->old_hash.notrace_hash = old_hash->notrace_hash;   // 代码替换前更新备份 old_hash
        ftrace_run_update_code(command);
        ops->old_hash.filter_hash = NULL;
        ops->old_hash.notrace_hash = NULL;
        ops->flags &= ~FTRACE_OPS_FL_MODIFYING;
}

// kernel/trace/ftrace.c ：2805

ftrace_run_update_code(command);
  arch_ftrace_update_code(command);
    ftrace_run_stop_machine(command);
      stop_machine(__ftrace_modify_code, &command, NULL);
        ftrace_modify_all_code(*command);

void ftrace_modify_all_code(int command){
        if (command & FTRACE_UPDATE_CALLS)
                ftrace_replace_code(mod_flags | FTRACE_MODIFY_ENABLE_FL);
}

void __weak ftrace_replace_code(int mod_flags){
  do_for_each_ftrace_rec(pg, rec){
    __ftrace_replace_code(rec, enable);
  }
}

// kernel/trace/ftrace.c ：2555

static int __ftrace_replace_code(struct dyn_ftrace *rec, bool enable)
{
        unsigned long ftrace_old_addr;
        unsigned long ftrace_addr;
        int ret;

        ftrace_addr = ftrace_get_addr_new(rec); // 选择要跳转的目标地址 FTRACE_ADDR ftrace_caller

        /* This needs to be done before we call ftrace_update_record */
        ftrace_old_addr = ftrace_get_addr_curr(rec);

        ret = ftrace_update_record(rec, enable); // 判断修改类型 MAKE_CALL: FMAKE_NOP:MODIFY_CALL:

        ftrace_bug_type = FTRACE_BUG_UNKNOWN;

        switch (ret) {
        case FTRACE_UPDATE_IGNORE:
                return 0;

        case FTRACE_UPDATE_MAKE_CALL:
                ftrace_bug_type = FTRACE_BUG_CALL;
                return ftrace_make_call(rec, ftrace_addr);  // 执行函数地址替换，从 nop 替换为 ftrace_caller

        case FTRACE_UPDATE_MAKE_NOP:
                ftrace_bug_type = FTRACE_BUG_NOP;
                return ftrace_make_nop(NULL, rec, ftrace_old_addr);

        case FTRACE_UPDATE_MODIFY_CALL:
                ftrace_bug_type = FTRACE_BUG_UPDATE;
                return ftrace_modify_call(rec, ftrace_old_addr, ftrace_addr);
        }

        return -1; /* unknown ftrace bug */
}

// arch/riscv/kernel/ftrace.c ：101

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;
}

// include/linux/ftrace.h ：132

typedef void (*ftrace_func_t)(unsigned long ip, unsigned long parent_ip,struct ftrace_ops *op, struct ftrace_regs *fregs);

// arch/riscv/kernel/mcount-dyn.S ：28
        .macro SAVE_ABI
        addi    sp, sp, -SZREG  // 8
        addi    sp, sp, -ABI_SIZE_ON_STACK // 9*8 = 72

        REG_S   a0, ABI_A0(sp)
        REG_S   a1, ABI_A1(sp)
        REG_S   a2, ABI_A2(sp)
        REG_S   a3, ABI_A3(sp)
        REG_S   a4, ABI_A4(sp)
        REG_S   a5, ABI_A5(sp)
        REG_S   a6, ABI_A6(sp)
        REG_S   a7, ABI_A7(sp)
        REG_S   ra, ABI_RA(sp)
        .endm

// arch/riscv/kernel/mcount-dyn.S ：114
ENTRY(ftrace_caller)
        SAVE_ABI

        addi    a0, ra, -FENTRY_RA_OFFSET
        la      a1, function_trace_op
        REG_L   a2, 0(a1)
        REG_L   a1, ABI_SIZE_ON_STACK(sp)
        mv      a3, sp

ftrace_call:
        .global ftrace_call
        call    ftrace_stub

        RESTORE_ABI
        ret
ENDPROC(ftrace_caller)