当前位置：首页 > news >正文

Linux内核gcov修改为模块

news 来源：原创 2025/7/13 8:40:10

Linux内核gcov修改为模块

Gcov 是 GNU 项目开发的代码覆盖率分析工具，与 GCC 编译器深度集成，用于统计程序运行时代码的执行情况，帮助开发者评估测试用例的完整性和代码质量。

Gcov工作原理

1. 编译插桩

编译时需添加 -fprofile-arcs -ftest-coverage 选项，GCC 会在代码中插入统计逻辑：

.gcno 文件：记录基本块（Basic Block）的图结构和源码行号信息。
**.gcda 文件**：运行时生成，存储实际执行路径的计数数据（如弧跳变次数）。

数据收集与分析

运行程序后（一定是调用gcc exit退出的，不能是被SIGINT等信号杀死），.gcda 文件生成于可执行文件所在目录。
执行 gcov <源文件> 命令，解析 .gcno 和 .gcda 文件，生成 .gcov 文本报告

内核从2.6.31 开始，Gcov 支持被合并到内核主线。通过下面两个配置选项开启：

CONFIG_GCOV_KERNEL=y      # 启用内核 Gcov 支持
CONFIG_GCOV_PROFILE_ALL=y # 统计整个内核的覆盖率

由于性能开销、资源占用、安全性和维护成本等几方面考虑，普通Linux发行版并不会打开此配置，如果想要统计测试覆盖率，只能自己重新编译内核，费时费力。

最近琢磨了一下把gcov做成模块，用户可以根据需要自行加载，挺有用的还，记录一下。

我们先实现一个hello_world测试模块，创建一个char设备，然后用户通过ioctl操作这个设备。下面是代码：

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>#define DEVICE_NAME "hello_ioctl"
#define CLASS_NAME "hello_class"// 设备操作函数声明
static int device_open(struct inode *, struct file *);
static int device_release(struct inode *, struct file *);
static ssize_t device_read(struct file *, char __user *, size_t, loff_t *);
static ssize_t device_write(struct file *, const char __user *, size_t, loff_t *);// 文件操作结构体
static struct file_operations fops = {.open = device_open,.release = device_release,.read = device_read,.write = device_write,
};// 设备号和类指针
static dev_t dev_num;
static struct class *hello_class = NULL;
static struct cdev hello_cdev;// 设备打开函数
static int device_open(struct inode *inode, struct file *file) {printk(KERN_INFO "Device opened\n");return 0;
}// 设备关闭函数
static int device_release(struct inode *inode, struct file *file) {printk(KERN_INFO "Device closed\n");return 0;
}// 设备读取函数
static ssize_t device_read(struct file *file, char __user *buf, size_t len, loff_t *offset) {printk(KERN_INFO "Device read\n");return 0;
}// 设备写入函数
static ssize_t device_write(struct file *file, const char __user *buf, size_t len, loff_t *offset) {printk(KERN_INFO "Device write\n");return len;
}// 模块初始化函数
static int __init hello_init(void) {int ret;// 动态分配设备号ret = alloc_chrdev_region(&dev_num, 0, 1, DEVICE_NAME);if (ret < 0) {printk(KERN_ERR "Failed to allocate device number\n");return ret;}// 创建设备类hello_class = class_create(THIS_MODULE, CLASS_NAME);if (IS_ERR(hello_class)) {unregister_chrdev_region(dev_num, 1);printk(KERN_ERR "Failed to create device class\n");return PTR_ERR(hello_class);}// 初始化并注册字符设备cdev_init(&hello_cdev, &fops);hello_cdev.owner = THIS_MODULE;ret = cdev_add(&hello_cdev, dev_num, 1);if (ret < 0) {class_destroy(hello_class);unregister_chrdev_region(dev_num, 1);printk(KERN_ERR "Failed to add cdev\n");return ret;}// 创建设备节点（触发udev自动创建/dev/hello_ioctl）device_create(hello_class, NULL, dev_num, NULL, DEVICE_NAME);printk(KERN_INFO "Device created successfully at /dev/%s\n", DEVICE_NAME);return 0;
}// 模块卸载函数
static void __exit hello_exit(void) {// 销毁设备节点device_destroy(hello_class, dev_num);// 销毁设备类class_destroy(hello_class);// 删除字符设备cdev_del(&hello_cdev);// 释放设备号unregister_chrdev_region(dev_num, 1);printk(KERN_INFO "Driver exited successfully\n");
}module_init(hello_init);
module_exit(hello_exit);MODULE_LICENSE("GPL");
MODULE_AUTHOR("YourName");
MODULE_DESCRIPTION("A simple character device driver demo");
MODULE_VERSION("1.0");

设备读写函数比较简单，都是往dmesg打印一行内容。仅仅是为了测试gcov统计代码调用次数的。这是Makefile

# Makefile内容
obj-m += helloworld.oall:make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modulesclean:make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

下面是用户态调用ioctl：

// 示例测试程序（test.c）
#include <stdio.h>
#include <fcntl.h>int main() {int fd = open("/dev/hello_ioctl", O_RDWR);if (fd < 0) {perror("Failed to open device");return -1;}write(fd, "test", 4);close(fd);return 0;
}

先测试一下基本功能，insmod之后ls /dev/hello_ioctl设备存在，然后编译运行test.c，dmesg能看到下面这些信息。
在这里插入图片描述

假定说test.c是测试helloworld.ko的用例，运行完后，我想知道ko模块多少代码被调用到了。gcov就提供了这个功能呢，按照前文，需要现在makefile里添加编译参数

ccflags-y += -fprofile-arcs -ftest-coverage

j
插桩完成后，make编译会提示

ERROR: modpost: "__gcov_merge_add" undefined!                                                                
ERROR: modpost: "__gcov_exit" undefined!
ERROR: modpost: "__gcov_init" undefined!

这是因为gcc会接在插入一段代码，调用到这几个函数，但是内核符号表里面又找不到这几个。这时候我们需要先把gcov修改为模块，主要就是添加一下module_exit 调用资源卸载回收之类的。写一个makefile，把gcov编译成ko就行。这里面文件太多而杂，就不一一展示了。等编译好gcov.ko之后，ls Module.symvers查看gcov符号表。
现在来编译helloworld模块吧，用KBUILD_EXTRA_SYMBOLS指定extra符号表，这样就不会再报错了。

make KBUILD_EXTRA_SYMBOLS=gcov符号表路径

gcc会在helloworld里面插入一个.init_array段，readelf时候就能看到：
在这里插入图片描述
这是gcc自动插入代码这部分是完成了，接下来只需要调用到init_array段,这样gcov就完成实现gcov功能了。内核在load_modules->do_init_module->do_mod_ctor真正执行init_array的功能，请注意do_mod_ctor是在执行do_one_initcall也就是注册好的module_init之前被调用到的。这个函数主要功能被CONFIG_CONSTRUCTORS宏框起来了，如果没打开GCOV_KERNEL的话，内核压根不会编译这块代码。

目前的思路是，通过kprobe分别在find_module_sections和do_init_module函数里注入代码，完成init_array段的查找和执行。内核为了安全起见，load_module函数u用到的很多结构和函数定义都是static，没关系在kprobe里照原样再定义一次就行，数据解析出来也是一样的，最终我们只是要init_array的地址就可以。下面是kprobe代码：

#define pr_fmt(fmt) "%s: " fmt, __func__#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/kprobes.h>static char find_symbol[64] = "find_module_sections";
static char init_symbol[64] = "do_init_module";
unsigned int num_ctors;         //number of init_array functions
ctor_fn_t *ctors;struct load_info {const char *name;/* pointer to module in temporary copy, freed at end of load_module() */struct module *mod;Elf_Ehdr *hdr;unsigned long len;Elf_Shdr *sechdrs;char *secstrings, *strtab;unsigned long symoffs, stroffs, init_typeoffs, core_typeoffs;struct _ddebug *debug;unsigned int num_debug;bool sig_ok;
#ifdef CONFIG_KALLSYMSunsigned long mod_kallsyms_init_off;
#endifstruct {unsigned int sym, str, mod, vers, info, pcpu;} index;
};struct load_info *info;static struct kprobe kp_find = {.symbol_name = find_symbol,
};
static struct kprobe kp_init = {.symbol_name = init_symbol,
};/* Find a module section: 0 means not found. */
static unsigned int find_sec(const struct load_info *info, const char *name)
{unsigned int i;for (i = 1; i < info->hdr->e_shnum; i++) {Elf_Shdr *shdr = &info->sechdrs[i];/* Alloc bit cleared means "ignore it." */if ((shdr->sh_flags & SHF_ALLOC)&& strcmp(info->secstrings + shdr->sh_name, name) == 0)return i;}return 0;
}/* Find a module section, or NULL.  Fill in number of "objects" in section. */
static void *section_objs(const struct load_info *info,const char *name,size_t object_size,unsigned int *num)
{unsigned int sec = find_sec(info, name);/* Section 0 has sh_addr 0 and sh_size 0. */*num = info->sechdrs[sec].sh_size / object_size;return (void *)info->sechdrs[sec].sh_addr;
}static int __kprobes init_handler_pre(struct kprobe *p, struct pt_regs *regs)
{struct module *mod;int i;//X86架构mod = regs->di;if(strcmp("helloworld", mod->name) == 0) {for(i = 0; i < num_ctors; i++) {if(ctors[i])ctors[i]();}}return 0;
}static int __kprobes find_handler_pre(struct kprobe *p, struct pt_regs *regs)
{struct module *mod;unsigned long i;mod = regs->di;info = regs->si;ctors = section_objs(info, ".ctors", sizeof(*ctors), &num_ctors);if(!ctors)ctors = section_objs(info, ".init_array", sizeof(*ctors), &num_ctors);else if(find_sec(info, "init_array")) {pr_warn("%s: has both .ctor and .init_array\n", mod->name);return -EINVAL;}return 0;
}static int __init kprobe_init(void) {int ret;kp_find.pre_handler = find_handler_pre;kp_init.pre_handler = init_handler_pre;ret = register_kprobe(&kp_find);if(ret < 0) {pr_err("register_kprobe find failed, returned %d\n", ret);return ret;}ret = register_kprobe(&kp_init);if(ret < 0) {pr_err("register_kprobe init failed, returned %d\n", ret);return ret;}return 0;
}static void __exit kprobe_exit(void) {unregister_kprobe(&kp_find);pr_info("kprobe at %p unregistered\n", kp_find.addr);unregister_kprobe(&kp_init);pr_info("kprobe at %p unregistered\n", kp_init.addr);
}module_init(kprobe_init);
module_exit(kprobe_exit);
MODULE_LICENSE("GPL");

insmod gcov.ko执行完成之后，在/sys/kernel/debug下生成gcov目录，目录下暂时只有一个reset文件，reset文件是后面删除内存中gcov data的，往此文件写入模块名字，可以清除所有data数据，从头开始统计。
插入kprobe和helloworld模块，在sys下会生成对应的路径，等测试用例执行结束后，可以看到data文件，用gcov分析即可得到覆盖率。

Linux内核gcov修改为模块

Gcov工作原理

相关文章：