关于linux内核调试的实现

晨曦之光 发布于 2012/04/10 15:03
阅读 1K+
收藏 1

linux提供了很多调试工具,比如我喜欢用的Systemtap,用起来很方便,几乎不用大动干戈就可以洞察到内核的一些很重要的行为,这一切是怎么做到的呢?本文带你在内核调试接口的冰山下面走一遭。
很多人都知道,所谓的调试技术无非就两种,一个是下断点,另一个是单步。一般都是在断点的位置开始单步的,这二者十分容易被混淆,很多人认为下了断点就是单步,实际上不是这样的。x86提供了丰富的功能来支持调试,对于断点的支持就是一个编码为0xcc的指令,也就是汇编码:int3,实际上是个中断,当 程序执行过程中遇到0xcc的操作码时,那么它就会触发一个中断,最终由中断处理程序来解决,而中断处理程序往往就是给调试器发信号,并且挂起当前线程,由调试器开始执行,而调试器的行为大家就都知道了,这主要用于用户进程/线程调试,具体看一下代码:
当int3发生时,陷入内核执行到do_int3

void __kprobes do_int3(struct pt_regs *regs, long error_code)

{

         trace_hardirqs_fixup();

         //以下就是调试内核相关的了,一会说内核,现在先说用户空间的0xcc

         if (notify_die(DIE_INT3, "int3", regs, error_code, 3, SIGTRAP)

                         == NOTIFY_STOP)

                 return;

         /*

          * This is an interrupt gate, because kprobes wants interrupts

          * disabled. Normal trap handlers don't.

          */

         restore_interrupts(regs);

         //关键操作,在这个do_trap里给自己发送一个SIGTRAP信号,在返回用户空间的路径上处理该信号,并且调用ptrace_notify来将控制权交给它的调试器。

        do_trap(3, SIGTRAP, "int3", 1, regs, error_code, NULL);

}

在handle_signal中,返回用户处理程序之前要调用以下代码,从而不等该进程返回用户空间就将其挂起,开始调试器的调试。

if (test_thread_flag(TIF_SINGLESTEP))
ptrace_notify(SIGTRAP);
不光是上面的单步检查,在get_signal_to_deliver中有个ptrace_signal才是真正的查点,所以说只要一个进程进入了int3中断处理,那么它就别指望回来了,马上调试器就要接管它了。也就是说只要用户代码中被插入了0xcc,那么就会进入do_int3,然后就会给自己发送一个信号,这样在do_int3返回的时候要执行do_signal。在其中会转入到调试器去执行。
以上说的就是用户的断点操作,那么单步是什么呢?单步实际上也是硬件的机制,只不过它不再是简单一条代码指令的问题
了,在硬件中有个flags标志寄存器,其中TF标志代表单步执行,那么cpu在每执行完一条指令的时候都会检查这个标志位,一旦设置了这个标志位,那么cpu当即触发一个1号中
断就是int1,这样cpu转入到中断处理,在linux中就是debug程序,就是在
初始化的时候设置的:set_intr_gate(1, &debug);,那debug函数在哪里呢?在entry_32.S里面:

KPROBE_ENTRY(debug)

         RING0_INT_FRAME

         cmpl $ia32_sysenter_target,(%esp)

         jne debug_stack_correct

         FIX_STACK(12, debug_stack_correct, debug_esp_fix_insn)

debug_stack_correct:

         pushl $-1                       # mark this as an int

         CFI_ADJUST_CFA_OFFSET 4

         SAVE_ALL

xorl %edx,%edx                  # error code 0

movl %esp,%eax                  # pt_regs pointer

         call do_debug

         jmp ret_from_exception

         CFI_ENDPROC

KPROBE_END(debug)

实际执行的是do_debug函数,它本质上也是一个向自己发送信号,然后在返回的途中被调试器拦截,从而进入调试器执行的一个过程,需要注意的是,在进入单步以后,一般要清除被中断的线程的单步寄存器标志位,否则就会无休止的进入单步中断处理这是不希望的,一般情况就是把控制权交给调试器,由调试器来做决定。
经过上面的叙述,很能看过的人就知道断点和单步的区别了,但是为何要有单步呢?你在某条指令下断,然后调试器执行,接着调试器再在下一条指令下断,不就完了吗?但是要知道,一条指令的执行分为pre,in,post三个阶段,分别为指令执行前,执行中,执行后,一般的调试器都要在前后两个位置安放自己的钩子函数,0xcc只能实现pre钩子,post却无法实现,那么这时就需要int1单步来帮忙了,在一条指令处下断,然后进入调试器,然后在调试器中设置单步,之后恢复原始指令的执行,这条原始指令执行完毕之后因为单步就会进入int1的do_debug进行处理,之后尽可能执行事先安置好的post钩子。用户线程的调试器比如gdb如果不方便看的话,我们下面就来看一下内核的调试器,专门调试内核的,用的就是上面我所叙述的方法,只不过在内核中没有所谓的调试进程,而是内核本身处理这发生的一切。linux内核中的调试接口就是一个叫kprobe的结构,该结构如下:

struct kprobe {

         struct hlist_node hlist;

         /* list of kprobes for multi-handler support */

         struct list_head list;

         /* Indicates that the corresponding module has been ref counted */

         unsigned int mod_refcounted;

         /*count the number of times this probe was temporarily disarmed */

         unsigned long nmissed;

         /* location of the probe point */

         kprobe_opcode_t *addr;

         /* Allow user to indicate symbol name of the probe point */

         const char *symbol_name;

         /* Offset into the symbol */

         unsigned int offset;

         /* Called before addr is executed. */

         kprobe_pre_handler_t pre_handler;

         /* Called after addr is executed, unless... */

         kprobe_post_handler_t post_handler;

         /* ... called if executing addr causes a fault (eg. page fault).

          * Return 1 if it handled fault, otherwise kernel will see it. */

         kprobe_fault_handler_t fault_handler;

         /* ... called if breakpoint trap occurs in probe handler.

          * Return 1 if it handled break, otherwise kernel will see it. */

         kprobe_break_handler_t break_handler;

         /* Saved opcode (which has been replaced with breakpoint) */

         kprobe_opcode_t opcode;

         /* copy of the original instruction */

         struct arch_specific_insn ainsn;

};

可 以看出,上面的结构包含一切调试内核所需要的信息,可以说就是一个调试器了,它起码包含有pre,post两个回调函数,作为钩子函数调用,实际过程就是 先注册一个kprobe,然后将需要调试的地址的前面改称0xcc,在int3处理函数中回调pre钩子函数,同时使能单步,之后恢复原始地址的指令执行,执行完后因为单步的原因进入了int1,在do_debug中执行post函数,执行完毕后冻结单步,恢复原始执行流,看似复杂,实际上和用户空间的 病毒是一样的道理,就是先跳入自己的钩子,等待执行完毕后再恢复原来的执行流,呵呵,可别得罪写内核的这帮家伙,他们发彪了能黑掉全世界的电脑...
本文不分析代码,只是简要讲述了调试执行的流程,可以自行研究代码的实现。实际上想要彻底理解调试器的原理,必须做的两件事就是:1.理解硬件调试寄存器 的功能和配置;2.理解代码。其实真正的接口是硬件提供的,代码只是实现了一个现在很时髦的“业务流程”。下面简要介绍一下代码中关键的部分:
1.注册:

static int __kprobes __register_kprobe(struct kprobe *p,

         unsigned long called_from)

{

         int ret = 0;

         struct kprobe *old_p;

         struct module *probed_mod;

         kprobe_opcode_t *addr;

         addr = kprobe_addr(p);//根据p的symbol_name和offset找到对应的内核空间地址

         if (!addr)

                 return -EINVAL;

         p->addr = addr;

         if (!kernel_text_address((unsigned long) p->addr) ||

             in_kprobes_functions((unsigned long) p->addr))

                 return -EINVAL;

         p->mod_refcounted = 0;

...//我们忽略内核模块的调试

         p->nmissed = 0;

         INIT_LIST_HEAD(&p->list);

         mutex_lock(&kprobe_mutex);

...//我们忽略重复调试

         ret = arch_prepare_kprobe(p);//备份原来的指令到一个地方,以便钩子执行完后恢复,是不是和病毒很像。

         if (ret)

                 goto out;

         INIT_HLIST_NODE(&p->hlist);

         hlist_add_head_rcu(&p->hlist,

                        &kprobe_table[hash_ptr(p->addr, KPROBE_HASH_BITS)]);

         if (kprobe_enabled)

                 arch_arm_kprobe(p);//下断点,就是将指令的前两字节改为0xcc

out:

         mutex_unlock(&kprobe_mutex);

         if (ret && probed_mod)

                 module_put(probed_mod);

         return ret;

}

2.触发int3:
这里用到了linux内核的通知链技术,在kprobe初始化的时候在die_chain通知链上注册了一个函数,每当函数执行die_notify的时 候就会调用这个函数,我想不通调试就调试呗,为啥注册这么恐怖一个通知链上,还die,吓谁呢?在int3处理的一开始就调用了die_notify,这 样就执行了下面的函数 :

static int __kprobes kprobe_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));

         if (*addr != BREAKPOINT_INSTRUCTION) {//这种情况说明断点已经被移出了

                 regs->ip = (unsigned long)addr;

                 return 1;

         }

         preempt_disable();

         kcb = get_kprobe_ctlblk();

         p = get_kprobe(addr);

         if (p) {

                 if (kprobe_running()) {

                         if (reenter_kprobe(p, regs, kcb))

                                 return 1;

                 } else {

                         set_current_kprobe(p, regs, kcb);

                         kcb->kprobe_status = KPROBE_HIT_ACTIVE;

                         if (!p->pre_handler || !p->pre_handler(p, regs))

                                 setup_singlestep(p, regs, kcb);//设置单步,具体就是设置regs的eflags

                         return 1;

                 }

         } else if (kprobe_running()) {

                 p = __get_cpu_var(current_kprobe);

                 if (p->break_handler && p->break_handler(p, regs)) {

                         setup_singlestep(p, regs, kcb);

                         return 1;

                 }

         } /* else: not a kprobe fault; let the kernel handle it */

         preempt_enable_no_resched();

         return 0;

}

3.触发int1
由于int3中设置了单步,那么int1在执行完一条指令后就要执行了,在int1的处理中主要就是恢复原始执行流,并且恢复之前调用post钩子,逻辑 上就是这么简单,代码就不分析了。今天十分不想写东西,但是还是将自己的想法写了出来,脑子越来越不好使,记忆力啊!


原文链接:http://blog.csdn.net/dog250/article/details/5303228
加载中
返回顶部
顶部