Linux 内核调试利器 | kprobe 的使用

发表于 3年以前 | 总阅读数：400 次

软件调试 是软件开发中一个必不可少的过程，通过软件调试可以排查系统中存在的 BUG。我们在开发应用层程序时，可以使用 GDB 对程序进行调试。但由于 GDB 只能调试应用层程序，并不能用于调试内核代码。

那么，如何调试内核代码呢？与调试应用层程序的 GDB 类似，调试内核代码也有个名叫 KGDB 的工具，但是使用起来比较繁琐。所以，本文将会介绍一个使用起来比较简单的内核调试工具：kprobe。

本篇文章主要介绍 kprobe 的使用，下篇文章将会介绍 kprobe 的实现原理。

kprobe 简介

回忆一下我们在开发应用程序时是怎样调试代码的？最原始的方法就是，在代码中使用 printf 这类打印函数把结果输出到屏幕或者日志中。当然在内核中有类似的打印函数：printk，但使用 printk 函数调试内核代码的话，必须要重新编译 Linux 内核代码，代价非常高。

所以，内核开发者们开发出一种不需要重新编译内核代码的调试工具：kprobe。

kprobe 可以让用户在内核几乎所有的地址空间或函数（某些函数是被能被探测的）中插入探测点，用户可以在这些探测点上通过定义自定义函数来调试内核代码。

用户可以对一个探测点进行执行前和执行后调试，在介绍 kprobe 的使用方式前，我们先来了解一下 struct kprobe 结构，其定义如下：

struct kprobe {
    ...
    kprobe_opcode_t        *addr;
    const char             *symbol_name;
    unsigned int           offset;

    kprobe_pre_handler_t   pre_handler;
    kprobe_post_handler_t  post_handler;
    kprobe_fault_handler_t fault_handler;
    ...
};

一个 struct kprobe 结构表示一个探测点，下面介绍一下其各个字段的作用：

addr：要探测的指令所在的内存地址（由于需要知道指令的内存地址，所以比较少使用）。
symbol_name：要探测的内核函数，symbol_name 与 addr 只能选择一个进行探测。
offset：探测点在内核函数内的偏移量，用于探测内核函数内部的指令，如果该值为0表示函数的入口。
pre_handler：在探测点处的指令执行前，被调用的调试函数。
post_handler：在探测点处的指令执行后，被调用的调试函数。
fault_handler：在执行 pre_handler、post_handler 或单步执行被探测指令时出现内存异常，则会调用这个回调函数。

一个 kprobe 探测点的执行过程如下图所示：

从上面的介绍可知，kprobe 一般用于调试内核函数。

kprobe 使用

接下来，我们介绍一下怎么使用 kprobe 来调试内核函数。

使用 kprobe 来进行内核调试的方式有两种：

第一种是通过编写内核模块，向内核注册探测点。探测函数可根据需要自行定制，使用灵活方便；
第二种方式是使用 kprobes on ftrace，这种方式是 kprobe 和 ftrace 结合使用，即可以通过 kprobe 来优化 ftrace 来跟踪函数的调用。

由于第一种方式灵活而且功能更为强大，所以本文主要介绍第一种使用方式。

要编写一个 kprobe 内核模块，可以按照以下步骤完成：

第一步：根据需要来编写探测函数，如 pre_handler 和 post_handler 回调函数。
第二步：定义 struct kprobe 结构并且填充其各个字段，如要探测的内核函数名和各个探测回调函数。
第三步：通过调用 register_kprobe 函数注册一个探测点。
第四步：编写 Makefile 文件。
第五步：编译并安装内核模块。

接下来就按照上面的步骤来完成一个 kprobe 的内核模块。

1. 定义回调函数

第一步就是编写追踪的回调函数，一般来说只需要编写 pre_handler、post_handler 和 fault_handler 这三个回调函数，当然也可以只编写你想追踪的其中某一个回调函数。下面我们将会完成这三个追踪回调函数的编写：

pre_handler 回调函数

我们首先编写要追踪的内核函数被调用前的回调函数 pre_handler，代码如下：

static int pre_handler(struct kprobe *p, struct pt_regs *regs)
{
    printk(KERN_INFO "pre_handler: p->addr = 0x%p, ip = %lx, flags = 0x%lx\n",
           p->addr, regs->ip, regs->flags);
    return 0;
}

上面的函数只是简单的打印了要追踪的内核函数的内存地址、ip 寄存器和 flags 寄存器的值，在函数的定义中可以发现有个类型为 pt_regs 结构的参数，其主要保存了 CPU 各个寄存器的值，不同 CPU 架构的定义不一样，例如 x86 CPU 架构的定义如下：

struct pt_regs {
    long ebx;        // ebx寄存器
    long ecx;        // ecx寄存器
    long edx;        // edx寄存器
    long esi;        // esi寄存器
    long edi;        // edi寄存器
    long ebp;        // ebp寄存器
    long eax;        // eax寄存器
    int  xds;        // ds寄存器
    int  xes;        // es寄存器
    int  xfs;        // fs寄存器
    long orig_eax;   // ...
    long eip;        // eip寄存器
    int  xcs;        // cs寄存器
    long eflags;     // eflags寄存器
    long esp;        // esp寄存器
    int  xss;        // ss寄存器
};

所以我们可以通过这个结构来获取 CPU 各个寄存器的值。

post_handler 回调函数

接着我们来编写要追踪的内核函数被调用后的回调函数 post_handler，其代码如下：

static void 
post_handler(struct kprobe *p, struct pt_regs *regs, unsigned long flags)
{
    printk(KERN_INFO "post_handler: p->addr = 0x%p, flags = 0x%lx\n",
           p->addr, regs->flags);
}

post_handler 回调函数也只是简单的打印了要追踪的内核函数的内存地址和 flags 寄存器的值。

fault_handler 回调函数

最后我们来编写当发生内存异常时的回调函数 fault_handler，其代码如下：

static int fault_handler(struct kprobe *p, struct pt_regs *regs, int trapnr)
{
    printk(KERN_INFO "fault_handler: p->addr = 0x%p, trap #%dn",
           p->addr, trapnr);
    return 0;
}

fault_handler 回调函数打印了要追踪的内核函数的内存地址和发生异常时的异常编号。

2. 定义 kprobe 结构

接下来我们定义一个 struct kprobe 结构并且填充其各个字段值，代码如下：

static struct kprobe kp = {
    .symbol_name   = "do_fork",      // 要追踪的内核函数为 do_fork
    .pre_handler   = pre_handler;    // pre_handler 回调函数
    .post_handler  = post_handler;   // post_handler 回调函数
    .fault_handler = fault_handler;  // fault_handler 回调函数
};

由于我们要追踪 do_fork 内核函数，所以在 kprobe 结构的 symbol_name 设置为 do_fork 字符串，然后设置各个回调函数即可。

3. 注册追踪点

最后通过调用 register_kprobe 函数来注册追踪点，代码如下：

static int __init kprobe_init(void)
{
    int ret;

    ret = register_kprobe(&kp); // 调用 register_kprobe 注册追踪点
    if (ret < 0) {
        printk(KERN_INFO "register_kprobe failed, returned %d\n", ret);
        return ret;
    }
    printk(KERN_INFO "planted kprobe at %p\n", kp.addr);
    return 0;
}

static void __exit kprobe_exit(void)
{
    unregister_kprobe(&kp); // 调用 unregister_kprobe 注销追踪点
    printk(KERN_INFO "kprobe at %p unregistered\n", kp.addr);
}

module_init(kprobe_init) // 注册模块初始化函数
module_exit(kprobe_exit) // 注册模块退出函数
MODULE_LICENSE("GPL");

4. 编写 Makefile 文件

Makefile 文件用于编译内核模块时使用，一般来说编译内核模块的 Makefile 格式相对固定，如下：

obj-m := kprobe_example.o # 编译后的二进制文件名

CROSS_COMPILE=''
KDIR := /lib/modules/$(shell uname -r)/build
all:
        make -C $(KDIR) M=$(PWD) modules 
clean:
        rm -f *.ko *.o *.mod.o *.mod.c .*.cmd *.symvers  modul*

5. 编译并安装内核模块

最后，我们编译并且安装这个内核模块，命令如下：

$ make
$ sudo insmod kprobe_example.ko

安装完成后，随便敲入一个命令（如 ls），然后通过调用 dmesg 命令查看内核模块输出的结果，如下所示：

...
planted kprobe at ffffffff81076400
pre_handler: p->addr = 0xffffffff81076400, ip = ffffffff81076401, flags = 0x246
post_handler: p->addr = 0xffffffff81076400, flags = 0x246
pre_handler: p->addr = 0xffffffff81076400, ip = ffffffff81076401, flags = 0x246
post_handler: p->addr = 0xffffffff81076400, flags = 0x246
pre_handler: p->addr = 0xffffffff81076400, ip = ffffffff81076401, flags = 0x246
post_handler: p->addr = 0xffffffff81076400, flags = 0x246

可以看出，我们的调试模块已经正常工作，并且输出我们需要的信息。