关于linux内核调试的实现

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钩子，逻辑 上就是这么简单，代码就不分析了。今天十分不想写东西，但是还是将自己的想法写了出来，脑子越来越不好使，记忆力啊！