手把手教你写Linux内核模块，快速掌握嵌入式驱动开发核心技能

第一章：手把手教你写Linux内核模块，快速掌握嵌入式驱动开发核心技能

编写Linux内核模块是深入理解操作系统底层机制和嵌入式驱动开发的关键一步。通过加载和卸载模块，开发者可以在不重启系统的情况下扩展内核功能，这对调试硬件驱动尤为重要。

环境准备与编译工具链配置

在开始之前，确保系统已安装必要的开发工具：

• Linux内核头文件（如 linux-headers-$(uname -r)）
• GNU 编译器集合（gcc）
• make 构建工具

可通过以下命令安装依赖（以Ubuntu为例）：

sudo apt update
sudo apt install build-essential linux-headers-$(uname -r)

编写最简单的内核模块

创建文件 hello_module.c，内容如下：

// hello_module.c
#include <linux/init.h>           // __init, __exit 宏定义
#include <linux/module.h>         // 所有模块都需要的头文件
#include <linux/kernel.h>         // KERN_INFO 等日志级别

// 模块加载时执行的函数
static int __init hello_init(void)
{
    printk(KERN_INFO "Hello, Linux Kernel Module!\n");
    return 0; // 成功加载
}

// 模块卸载时执行的函数
static void __exit hello_exit(void)
{
    printk(KERN_INFO "Goodbye, Linux Kernel Module!\n");
}

module_init(hello_init);    // 注册模块入口
module_exit(hello_exit);    // 注册模块出口

MODULE_LICENSE("GPL");              // 声明许可证
MODULE_AUTHOR("Developer");         // 作者信息
MODULE_DESCRIPTION("A simple test module"); // 模块描述

构建模块的Makefile

编写同目录下的 Makefile：

obj-m += hello_module.o

KDIR := /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)

default:
	$(MAKE) -C $(KDIR) M=$(PWD) modules

clean:
	$(MAKE) -C $(KDIR) M=$(PWD) clean

执行 make 编译模块，生成 hello_module.ko。

加载与卸载模块

使用以下命令管理模块：

1. sudo insmod hello_module.ko —— 加载模块
2. dmesg | tail —— 查看内核日志输出
3. sudo rmmod hello_module —— 卸载模块

命令	作用
insmod	插入模块到内核
rmmod	移除已加载模块
dmesg	查看内核消息缓冲区

第二章：Linux内核模块基础与环境搭建

2.1 内核模块的编译机制与Kbuild系统详解

Linux内核模块的编译依赖于Kbuild系统，它是一套专为内核构建设计的Makefile逻辑集合。用户无需编写完整的Makefile，只需定义必要的变量即可完成模块构建。

基本编译流程

最简单的内核模块编译需要一个源文件和一个Makefile。例如：

obj-m += hello_module.o
KDIR := /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)
default:
	$(MAKE) -C $(KDIR) M=$(PWD) modules

其中，obj-m 表示将目标文件编译为可加载模块；-C 切换到内核源码目录；M= 指定外部模块路径。Kbuild会自动识别*.o依赖并生成.ko文件。

Kbuild关键变量

• obj-y：编译进内核镜像的目标文件
• obj-m：编译为可加载模块的目标文件
• ccflags-y：传递给C编译器的额外标志

Kbuild通过递归调用内核构建系统，复用内核的编译配置、头文件路径和架构设置，确保模块与运行内核兼容。

2.2 搭建交叉编译环境与开发板烧录流程

安装交叉编译工具链

在宿主机上搭建嵌入式开发环境的第一步是安装适用于目标架构的交叉编译器。以 ARM 架构为例，Ubuntu 系统可通过以下命令安装：

sudo apt-get install gcc-arm-linux-gnueabihf

该命令安装了针对 ARM Cortex-A 系列处理器的 GCC 编译工具链，其中 arm-linux-gnueabihf 表示目标平台为 ARM，使用硬浮点 ABI。

验证编译器可用性

执行以下命令验证安装结果：

arm-linux-gnueabihf-gcc --version

正常输出应包含版本信息及目标架构说明。

烧录流程概述

开发板烧录通常包括以下步骤：

1. 将编译生成的镜像文件（如 kernel.img）拷贝至 SD 卡根目录
2. 通过 USB 或串口连接烧录工具（如 fastboot）
3. 执行烧录指令写入 eMMC 或 NAND 闪存

2.3 编写第一个可加载的Hello World模块并调试

模块代码实现

#include <linux/module.h>
#include <linux/kernel.h>

static int __init hello_init(void)
{
    printk(KERN_INFO "Hello, World!\n");
    return 0;
}

static void __exit hello_exit(void)
{
    printk(KERN_INFO "Goodbye, World!\n");
}

module_init(hello_init);
module_exit(hello_exit);
MODULE_LICENSE("GPL");

该代码定义了一个最简单的内核模块，hello_init 在模块加载时执行，通过 printk 输出信息；hello_exit 在卸载时调用。宏 MODULE_LICENSE("GPL") 避免内核污染警告。

编译与调试流程

• 编写 Makefile：使用 obj-m := hello.o 指定生成模块
• 执行编译：make -C /lib/modules/$(uname -r)/build M=$(PWD) modules
• 加载模块：sudo insmod hello.ko
• 查看日志：dmesg | tail
• 卸载模块：sudo rmmod hello

2.4 模块参数传递与符号导出机制实战

在Linux内核模块开发中，参数传递与符号导出是实现模块间通信的关键机制。通过module_param()宏可定义可被用户空间修改的模块参数。

模块参数定义示例

#include <linux/module.h>
static int timeout = 5;
module_param(timeout, int, 0644);
MODULE_PARM_DESC(timeout, "超时时间（秒）");

上述代码将timeout变量注册为模块参数，加载时可通过insmod mymodule.ko timeout=10动态赋值。

符号导出机制

使用EXPORT_SYMBOL()可将函数或变量导出供其他模块使用：

int shared_function(void) { return 42; }
EXPORT_SYMBOL(shared_function);

该函数在其他模块中声明为extern int shared_function(void);后即可调用。

宏定义	用途
module_param(name, type, perm)	注册模块参数
MODULE_PARM_DESC()	添加参数描述
EXPORT_SYMBOL()	导出符号

2.5 利用printk进行内核日志分析与问题定位

printk的基本使用

printk 是 Linux 内核中最基础且强大的调试工具，用于向内核日志缓冲区输出调试信息。其用法类似于用户空间的 printf，但需指定日志级别。

printk(KERN_INFO "Device opened by process %d\n", current->pid);

上述代码中，KERN_INFO 为日志级别宏，用于控制消息的优先级。内核共定义8个级别，从 KERN_EMERG（最高）到 KERN_DEBUG（最低）。只有当前控制台日志级别低于该值时，消息才会显示。

日志级别与过滤机制

• KERN_ERR：错误事件，需要立即关注
• KERN_WARNING：警告，可能影响稳定性
• KERN_INFO：普通信息性消息
• KERN_DEBUG：调试专用，通常被屏蔽

实时日志查看

通过 dmesg -H 可以以人类可读格式查看内核日志，结合 tail -f /var/log/kern.log 实现动态监控，快速定位驱动加载失败、内存分配异常等问题。

第三章：设备树原理与硬件描述配置

3.1 设备树基本结构与dts/dtb编译过程解析

设备树（Device Tree）是一种描述硬件资源与层次关系的数据结构，广泛应用于嵌入式Linux系统中。它通过文本文件 `.dts`（Device Tree Source）定义硬件信息，并经编译生成二进制 `.dtb` 文件供内核解析。

设备树源文件结构

一个典型的 `.dts` 文件包含节点和属性，描述CPU、内存、外设等信息。例如：

/ {
    model = "My Embedded Board";
    compatible = "myboard";

    cpus {
        #address-cells = <1>;
        #size-cells = <1>;
        cpu@0 {
            compatible = "arm,cortex-a9";
            reg = <0x0>;
        };
    };

    serial@10000000 {
        compatible = "ns16550a";
        reg = <0x10000000 0x1000>;
        interrupts = <3>;
    };
};

上述代码定义了根节点、CPU和串口设备。`compatible` 属性用于匹配驱动，`reg` 描述寄存器地址与长度，`interrupts` 指定中断号。

dts 到 dtb 的编译流程

设备树通过 `dtc`（Device Tree Compiler）工具链编译：

1. 编写 .dts 源文件
2. 引用头文件（如 .dtsi）进行架构复用
3. 调用 dtc 编译为 .dtb

命令示例：dtc -I dts -O dtb -o board.dtb board.dts，生成的 `.dtb` 在启动时由 bootloader 传递给内核。

3.2 在设备树中添加自定义节点并与驱动匹配

在嵌入式Linux系统中，设备树（Device Tree）用于描述硬件资源。通过在设备树源文件（.dts）中添加自定义节点，可以将外设信息传递给内核。

定义设备树节点

例如，在DTS文件中添加一个GPIO控制的LED节点：

myled {
    compatible = "mycompany,myled";
    status = "okay";
    gpios = <&gpio1 18 GPIO_ACTIVE_HIGH>;
};

其中，compatible 字符串是驱动匹配的关键，必须与驱动代码中的 .of_match_table 一致；gpios 描述所使用的GPIO资源。

驱动中的匹配机制

驱动程序通过 of_match_table 指定支持的设备：

static const struct of_device_id myled_of_match[] = {
    { .compatible = "mycompany,myled" },
    { /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, myled_of_match);

当内核初始化时，会根据设备树节点的 compatible 属性与驱动表进行匹配，成功后调用驱动的 probe 函数完成绑定。

3.3 使用OF API从设备树提取硬件资源信息

在Linux内核中，Open Firmware (OF) API提供了一组函数，用于从设备树（Device Tree）中解析和获取硬件资源配置。这些API使得驱动程序能够与平台无关地访问设备资源。

常用OF API函数

• of_get_property()：获取指定属性的值；
• of_find_node_by_name()：根据名称查找设备节点；
• of_iomap()：将设备树中的寄存器地址映射到内核虚拟地址空间。

示例：读取寄存器地址并映射

struct device_node *np;
void __iomem *base;

np = of_find_compatible_node(NULL, NULL, "fsl,imx6q-gpt");
if (!np) {
    pr_err("Failed to find device node\n");
    return -ENODEV;
}
base = of_iomap(np, 0);
if (!base)
    return -ENOMEM;

上述代码首先通过兼容性字符串查找设备节点，成功后调用of_iomap()将第一个寄存器区域映射至内存。参数0表示资源索引，通常对应设备树中reg属性的第一个地址段。

第四章：字符设备驱动开发全流程实践

4.1 注册字符设备与动态分配设备号实战

在Linux内核开发中，注册字符设备是驱动开发的第一步。使用`alloc_chrdev_region()`可实现设备号的动态分配，避免设备号冲突。

核心API说明

该函数原型如下：

int alloc_chrdev_region(dev_t *dev, unsigned int firstminor,
                        unsigned int count, const char *name);

其中，`dev`用于返回分配的设备号，`firstminor`指定首个次设备号，`count`为请求的设备数量，`name`是设备名称，出现在/proc/devices中。

设备注册流程

• 调用alloc_chrdev_region获取主次设备号
• 初始化cdev结构体并绑定文件操作集
• 通过cdev_add将设备添加到系统

成功注册后，需在卸载时调用unregister_chrdev_region()释放设备号资源，确保系统稳定性。

4.2 实现file_operations中的常用操作接口

在Linux内核模块开发中，`file_operations`结构体是设备驱动与VFS（虚拟文件系统）交互的核心。通过填充该结构体的函数指针，可实现对设备文件的读写、控制等操作。

关键操作接口示例

static struct file_operations my_fops = {
    .read = my_read,
    .write = my_write,
    .open = my_open,
    .release = my_release,
};

上述代码定义了一个简单的`file_operations`结构体实例，其中`.read`和`.write`分别指向用户空间读写设备时调用的函数。

常用成员函数说明

• open()：设备打开时调用，用于初始化硬件或资源分配；
• release()：关闭设备时执行清理工作；
• read()/write()：实现用户空间与内核空间的数据传输。

这些接口需严格遵循内核API规范，确保数据一致性与系统稳定性。

4.3 驱动中实现内存映射与I/O控制命令

在Linux设备驱动开发中，内存映射（mmap）和I/O控制（ioctl）是用户空间与内核空间高效交互的核心机制。

内存映射的实现

通过`mmap`系统调用，用户进程可直接访问设备物理内存，避免数据拷贝开销。驱动需实现`file_operations`中的`mmap`函数：

static int example_mmap(struct file *filp, struct vm_area_struct *vma)
{
    unsigned long pfn;
    vma->vm_flags |= VM_IO | VM_DONTEXPAND | VM_DONTDUMP;
    vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
    pfn = __phys_to_pfn(device_phys_addr);
    return remap_pfn_range(vma, vma->vm_start, pfn + vma->vm_pgoff,
                           vma->vm_end - vma->vm_start, vma->vm_page_prot);
}

该函数将设备物理地址转换为页帧号（PFN），并通过`remap_pfn_range`映射到用户虚拟地址空间，适用于视频缓冲区或寄存器访问。

I/O控制命令设计

`ioctl`用于发送控制指令，如启动设备、配置参数。常用命令定义如下：

命令	功能描述
EX_IOC_START	启动设备运行
EX_IOC_STOP	停止设备操作
EX_IOC_SET_MODE	设置工作模式

4.4 结合设备树完成LED驱动的完整开发案例

在嵌入式Linux系统中，通过设备树（Device Tree）描述硬件信息，可实现驱动与平台的解耦。以LED驱动为例，首先在设备树文件中定义LED节点：

leds {
    compatible = "myled,leds";
    led-gpio = &gpio1 19 0;
};

该节点声明了兼容性字符串和GPIO引脚。驱动程序通过of_match_table匹配此属性。

驱动加载流程

使用platform_driver结构注册驱动，内核根据设备树节点自动调用probe函数。关键代码如下：

static const struct of_device_id myled_of_match[] = {
    { .compatible = "myled,leds" },
    { }
};

通过of_get_named_gpio解析设备树中的GPIO配置，获取控制引脚。

资源管理与控制

函数	作用
devm_gpiod_get	获取受托管的GPIO句柄
gpiod_set_value	设置LED开关状态

第五章：嵌入式驱动开发进阶路径与职业能力构建

掌握核心外设驱动开发模式

嵌入式系统中，GPIO、I2C、SPI 和 UART 是最常见的外设接口。以 Linux 内核模块方式编写 I2C 设备驱动时，需注册 i2c_driver 结构体，并实现 probe 与 remove 回调函数：

static struct i2c_driver sensor_driver = {
    .driver = {
        .name = "temp_sensor",
        .owner = THIS_MODULE,
    },
    .probe = sensor_probe,
    .remove = sensor_remove,
    .id_table = sensor_id,
};

深入设备树与硬件抽象层集成

现代嵌入式平台广泛采用设备树（Device Tree）描述硬件资源。开发者需熟练编写 .dts 文件，将外设寄存器地址、中断号、兼容性字符串等信息传递给内核。例如：

i2c1: i2c@40003000 {
    status = "okay";
    clock-frequency = <100000>;
    temperature-sensor@48 {
        compatible = "ti,tmp102";
        reg = <0x48>;
    };
};

构建可复用的驱动框架设计

为提升代码可维护性，建议采用分层架构：底层处理寄存器读写，中间层封装设备状态机，上层提供 sysfs 或字符设备接口。常见设计模式包括：

• 使用 platform_driver 解耦硬件差异
• 通过 ioctl 实现用户空间控制命令
• 利用 completion 或 workqueue 处理异步事件

性能调优与调试实战策略

在实时性要求高的场景中，需减少中断延迟。可通过内核抢占配置（PREEMPT_RT）优化响应时间。结合 ftrace 与 perf 工具分析函数执行路径：

工具	用途
strace	追踪用户态系统调用耗时
kgdb	内核源码级远程调试