之前的文章介绍了基于 tracepoint 静态追踪技术的实现,本文再介绍基于 kprobe 的动态追踪即使的实现。同样,动态追踪也是排查问题的利器。
kprobe 是内核提供的动态追踪技术机制,它允许动态安装内核模块的方式安装系统钩子,非常强大。下面先看一个内核中的例子。
- #include
- #include
- #include
-
- #define MAX_SYMBOL_LEN 64
- // 要 hanck 的内核函数名
- static char symbol[MAX_SYMBOL_LEN] = "_do_fork";
- module_param_string(symbol, symbol, sizeof(symbol), 0644);
- static struct kprobe kp = {
- .symbol_name = symbol,
- };
-
- // 执行系统函数前被执行的钩子
- static int __kprobes handler_pre(struct kprobe *p, struct pt_regs *regs){
- // ...
- }
-
- // 执行系统函数的单条指令后执行的钩子(不是执行完系统函数)
- static void __kprobes handler_post(struct kprobe *p, struct pt_regs *regs,
- unsigned long flags){
- // ...
- }
-
- // 钩子执行出错或者单条执行执行出错时被执行函数static int handler_fault(struct kprobe *p, struct pt_regs *regs, int trapnr){
- // ...
- }
-
- static int __init kprobe_init(void){
- int ret;
- // 设置钩子
- kp.pre_handler = handler_pre;
- kp.post_handler = handler_post;
- kp.fault_handler = handler_fault;
- // 安装钩子
- register_kprobe(&kp);
- return 0;
- }
-
- static void __exit kprobe_exit(void){
- unregister_kprobe(&kp);
- pr_info("kprobe at %p unregistered\n", kp.addr);
- }
-
- // 安装进内核后的初始化和注销函数
- module_init(kprobe_init)
- module_exit(kprobe_exit)
- MODULE_LICENSE("GPL");
设置完 kprobe 后,通过 register_kprobe 注册到内核。
- int register_kprobe(struct kprobe *p){
- int ret;
- struct kprobe *old_p;
- struct module *probed_mod;
- kprobe_opcode_t *addr;
-
- // 通过系统函数名找到对应的地址,内核维护了这个数据
- addr = kprobe_addr(p);
- // 记录这个地址
- p->addr = addr;
- p->flags &= KPROBE_FLAG_DISABLED;
- p->nmissed = 0;
- INIT_LIST_HEAD(&p->list);
- // 之前是否已经存在钩子,是的话就插入存在的列表,否则插入一个新的记录
- old_p = get_kprobe(p->addr);
- if (old_p) {
-
- ret = register_aggr_kprobe(old_p, p);
- goto out;
- }
- // 把被 hack 的系统函数的指令保存到 probe 结构体,因为下面要覆盖这块内存
-
- ret = prepare_kprobe(p);
-
- INIT_HLIST_NODE(&p->hlist);
- // 插入内核维护的哈希表
- hlist_add_head_rcu(&p->hlist,
- &kprobe_table[hash_ptr(p->addr, KPROBE_HASH_BITS)]);
- // hack 掉系统函数所在内存的内容
- arm_kprobe(p);
- }
注册一个 probe,首先是通过被 hack 的函数名找到对应的地址,然后保存这个地址对应内存的信息,接着把 probe 插入哈希表,最后调用 arm_kprobe 函数 hack 掉系统函数所在内存的内容。看一下 arm_kprobe。
- void arch_arm_kprobe(struct kprobe *p){
- // #define INT3_INSN_OPCODE 0xCC
- u8 int3 = INT3_INSN_OPCODE;
- // 把 int3 的内存复制到 addr
- text_poke(p->addr, &int3, 1);
- text_poke_sync();
- perf_event_text_poke(p->addr, &p->opcode, 1, &int3, 1);
- }
0xCC 是 intel 架构下 int3 对应的指令。所以这里就是把被 hack 函数对应指令的前面部分改成 int3。完成 hack。当执行到系统函数的时候,就会执行 int3,从而触发 trap,并执行对应的处理函数 do_int3(这里比较复杂,我也没有深入分析,大概是这个流程)。
- static bool do_int3(struct pt_regs *regs){
- kprobe_int3_handler(regs);}int kprobe_int3_handler(struct pt_regs *regs){
- kprobe_opcode_t *addr;
- struct kprobe *p;
- struct kprobe_ctlblk *kcb;
- addr = (kprobe_opcode_t *)(regs->ip - sizeof(kprobe_opcode_t));
-
- kcb = get_kprobe_ctlblk();
- // 通过地址从 probe 哈希表拿到对应的 probe 结构体
- p = get_kprobe(addr);
-
- set_current_kprobe(p, regs, kcb);
- kcb->kprobe_status = KPROBE_HIT_ACTIVE;
-
- // 执行 pre_handler 钩子
- if (!p->pre_handler || !p->pre_handler(p, regs))
- setup_singlestep(p, regs, kcb, 0);
- }
执行完。pre_handler 钩子后,会通过 setup_singlestep 设置单步执行 flag。
- static void setup_singlestep(struct kprobe *p, struct pt_regs *regs,
- struct kprobe_ctlblk *kcb, int reenter){
- // 修改寄存器的值
- // 设置 eflags 寄存器的 tf 位,允许单步调试
- regs->flags |= X86_EFLAGS_TF;
- regs->flags &= ~X86_EFLAGS_IF;
- // 设置下一条指令为系统函数的指令
- if (p->opcode == INT3_INSN_OPCODE)
- regs->ip = (unsigned long)p->addr;
- else
- regs->ip = (unsigned long)p->ainsn.insn;
- }
setup_singlestep 首先设置了允许单步调试,也就是说执行下一条指令后会触发一个 trap,从而执行一个处理函数。并设置了下一条指令为被 hack 函数对应的指令,这是在注册 probe 时保存下来的。触发单步调试的 trap 后,最终会执行到 kprobe_debug_handler
- int kprobe_debug_handler(struct pt_regs *regs){
- struct kprobe *cur = kprobe_running();
- struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
- // 恢复指令为系统函数的指令
- resume_execution(cur, regs, kcb);
- regs->flags |= kcb->kprobe_saved_flags;
- // 执行 post 钩子
- if ((kcb->kprobe_status != KPROBE_REENTER) && cur->post_handler) {
- kcb->kprobe_status = KPROBE_HIT_SSDONE;
- cur->post_handler(cur, regs, 0);
- }
- }
在单步调试的 trap 处理函数中,会执行 post 钩子,并恢复真正的系统函数执行。这就完成了整个过程。
我们可以看到 kprobe 可以在系统函数执行前执行我们的钩子,另外内核还提供了另外一个机制 kretprobe 用于在系统函数执行后返回前安装钩子。下面通过一个例子大致看一下 kretprobe。
- struct my_data {
- ktime_t entry_stamp;
- };
-
- // 记录函数执行开始时间
- static int entry_handler(struct kretprobe_instance *ri, struct pt_regs *regs){
- struct my_data *data;
- data = (struct my_data *)ri->data;
- data->entry_stamp = ktime_get();
- return 0;
- }
-
- // 记录函数执行结束时间
- static int ret_handler(struct kretprobe_instance *ri, struct pt_regs *regs){
- unsigned long retval = regs_return_value(regs);
- struct my_data *data = (struct my_data *)ri->data;
- s64 delta;
- ktime_t now;
-
- now = ktime_get();
- delta = ktime_to_ns(ktime_sub(now, data->entry_stamp));
- return 0;
- }
-
- static struct kretprobe my_kretprobe = {
- // 函数返回前执行
- .handler = ret_handler,
- // 函数开始前执行
- .entry_handler = entry_handler,
- .data_size = sizeof(struct my_data),
-
- .maxactive = 20,
- };
-
- static char func_name[NAME_MAX] = "_do_fork";
- module_param_string(func, func_name, NAME_MAX, S_IRUGO);
- my_kretprobe.kp.symbol_name = func_name;
- // 注册
- register_kretprobe(&my_kretprobe);
我们可以看到可以通过 kretprobe 计算系统函数的耗时。kretprobe 是基于 kprobe 实现的,主要逻辑是通过通过 kprobe 注册一个 pre_handler,在 pre_handler 中 hack 掉函数的栈,因为函数执行时,返回地址是存在栈中的,把这个内存改成一段内核的代码,等到函数执行完后,弹出返回地址时,就会执行内核 hack 的代码,从而执行我们的钩子,执行完后再跳回到真正的返回地址继续执行。
总结:内核通过劫持的方式实现了 kprobe,基于 kprobe 的动态追踪技术可谓是非常复杂而强大,我们可以利用这个机制,动态修改逻辑,收集信息。不过实现过于复杂,涉及到对 CPU 架构和内存模型的了解,本文也是大致分析了一下流程,有兴趣的同学可以自行查看源码。