📚 课程目录第2章字符设备驱动框架

2. 字符设备驱动框架：file_operations结构体、主次设备号、设备节点创建

字符设备是Linux驱动中最基础、最常用的设备类型，其核心交互模型为“用户空间通过文件接口操作硬件”。本章将深入剖析字符设备驱动的三大支柱：file_operations结构体、主次设备号管理以及设备节点的自动创建机制。

  核心要点：字符设备驱动的本质是“将硬件操作函数注册到VFS层”，通过设备号与设备节点建立用户空间到内核空间的桥梁。

2.1 字符设备驱动整体架构

下图展示了字符设备驱动在Linux系统中的位置与交互流程：

理解要点：用户空间的open("/dev/gpio_led", O_RDWR)经过VFS查找设备节点对应的主次设备号，最终调用到驱动中注册的gpio_led_open()函数。

2.2 file_operations 结构体详解

file_operations是字符设备驱动的“函数跳转表”，定义在<linux/fs.h>中。每个成员都是一个函数指针，对应一个系统调用。

成员名称	系统调用触发	典型用途	返回值
`.open`	`open()`	初始化设备、申请资源、递增使用计数	0成功 / 负值错误
`.release`	`close()`	释放资源、递减使用计数	0成功 / 负值错误
`.read`	`read()`	从硬件读取数据到用户缓冲区	读取字节数 / 负值错误
`.write`	`write()`	从用户缓冲区写入数据到硬件	写入字节数 / 负值错误
`.unlocked_ioctl`	`ioctl()`	非标准硬件控制命令（如GPIO方向设置）	0成功 / 负值错误
`.llseek`	`lseek()`	调整文件读写位置（字符设备通常不支持）	新位置 / 负值错误

常见错误：忘记实现.release会导致设备关闭时资源泄漏；.read和.write的缓冲区操作必须使用copy_to_user/copy_from_user，禁止直接解引用用户空间指针。

标准实现模板：

// 定义驱动函数
static int gpio_led_open(struct inode *inode, struct file *filp) {
    // 初始化硬件、递增模块计数
    try_module_get(THIS_MODULE);
    return 0;
}

static int gpio_led_release(struct inode *inode, struct file *filp) {
    // 释放资源、递减模块计数
    module_put(THIS_MODULE);
    return 0;
}

static ssize_t gpio_led_read(struct file *filp, char __user *buf,
                             size_t count, loff_t *f_pos) {
    // 读取GPIO电平状态
    char value;
    value = gpio_get_value(LED_GPIO);
    if (copy_to_user(buf, &value, 1))
        return -EFAULT;
    return 1;
}

static ssize_t gpio_led_write(struct file *filp, const char __user *buf,
                              size_t count, loff_t *f_pos) {
    char value;
    if (copy_from_user(&value, buf, 1))
        return -EFAULT;
    gpio_set_value(LED_GPIO, value);
    return 1;
}

// 注册 file_operations 结构体
static struct file_operations gpio_led_fops = {
    .owner   = THIS_MODULE,
    .open    = gpio_led_open,
    .release = gpio_led_release,
    .read    = gpio_led_read,
    .write   = gpio_led_write,
};

2.3 主次设备号：设备的“身份证”

设备号是内核识别设备的唯一标识，由主设备号 (major)和次设备号 (minor)组成，类型为dev_t（32位无符号整数）。

概念	位数	作用	分配方式
主设备号 (major)	高12位	标识设备对应的驱动程序	静态分配（手动指定）或动态分配（内核自动）
次设备号 (minor)	低20位	标识同一驱动下的不同设备实例	驱动开发者自行管理

设备号操作宏：

#include <linux/types.h>   // dev_t
#include <linux/kdev_t.h>  // MAJOR/MINOR/MKDEV

dev_t dev_num = MKDEV(250, 0);   // 构造设备号：主=250，次=0
int major = MAJOR(dev_num);      // 提取主设备号 → 250
int minor = MINOR(dev_num);      // 提取次设备号 → 0

设备号分配策略对比：

策略	函数	优点	缺点	推荐场景
静态分配	`register_chrdev_region()`	设备号固定，便于udev规则匹配	可能与其他驱动冲突	广泛使用的标准设备
动态分配	`alloc_chrdev_region()`	避免冲突，自动分配空闲号	设备号不固定，需查看`/proc/devices`	个人/实验驱动

  最佳实践：开发阶段使用动态分配，通过cat /proc/devices查看分配结果；产品阶段可切换为静态分配以固定设备号。

2.4 设备节点创建：从设备号到/dev文件

设备节点是用户空间访问驱动的入口，本质是一个特殊的文件，记录了主次设备号和文件类型（字符设备为c）。

手动创建设备节点：

# 查看已注册的设备号
cat /proc/devices | grep gpio_led

# 手动创建设备节点（主设备号250，次设备号0）
sudo mknod /dev/gpio_led c 250 0
sudo chmod 666 /dev/gpio_led

自动创建设备节点（推荐）：使用内核的class_create和device_create API，配合用户空间的udev或mdev自动生成。

#include <linux/device.h>

static struct class *gpio_led_class;
static struct device *gpio_led_device;

// 在模块初始化函数中
gpio_led_class = class_create(THIS_MODULE, "gpio_led_class");
if (IS_ERR(gpio_led_class))
    return PTR_ERR(gpio_led_class);

gpio_led_device = device_create(gpio_led_class, NULL, dev_num,
                                NULL, "gpio_led");
if (IS_ERR(gpio_led_device)) {
    class_destroy(gpio_led_class);
    return PTR_ERR(gpio_led_device);
}

// 在模块退出函数中
device_destroy(gpio_led_class, dev_num);
class_destroy(gpio_led_class);

自动创建原理：device_create()会在sysfs中创建/sys/class/gpio_led_class/gpio_led/目录，udev监听到uevent事件后，根据规则自动在/dev/下生成设备节点。

2.5 完整注册流程与SVG时序图

字符设备驱动的完整注册流程包含以下步骤：

分配设备号：使用alloc_chrdev_region()或register_chrdev_region()
初始化cdev：使用cdev_init()绑定file_operations
添加cdev：使用cdev_add()将设备注册到内核
创建类：使用class_create()创建设备类
创建设备：使用device_create()触发udev自动生成节点

2.6 完整驱动框架代码

以下是一个完整的字符设备驱动框架，整合了上述所有要素：

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/uaccess.h>

#define GPIO_LED_MAJOR 0   // 0表示动态分配
#define GPIO_LED_MINOR 0
#define GPIO_LED_CNT   1

static dev_t gpio_led_dev_num;
static struct cdev gpio_led_cdev;
static struct class *gpio_led_class;
static struct device *gpio_led_device;

// 模拟GPIO状态（实际驱动中操作硬件寄存器）
static int gpio_led_value = 0;

static int gpio_led_open(struct inode *inode, struct file *filp) {
    try_module_get(THIS_MODULE);
    pr_info("gpio_led: device opened\n");
    return 0;
}

static int gpio_led_release(struct inode *inode, struct file *filp) {
    module_put(THIS_MODULE);
    pr_info("gpio_led: device closed\n");
    return 0;
}

static ssize_t gpio_led_read(struct file *filp, char __user *buf,
                             size_t count, loff_t *f_pos) {
    if (count < 1) return -EINVAL;
    if (copy_to_user(buf, &gpio_led_value, 1))
        return -EFAULT;
    return 1;
}

static ssize_t gpio_led_write(struct file *filp, const char __user *buf,
                              size_t count, loff_t *f_pos) {
    char value;
    if (count < 1) return -EINVAL;
    if (copy_from_user(&value, buf, 1))
        return -EFAULT;
    gpio_led_value = value;
    pr_info("gpio_led: set value = %d\n", gpio_led_value);
    return 1;
}

static struct file_operations gpio_led_fops = {
    .owner   = THIS_MODULE,
    .open    = gpio_led_open,
    .release = gpio_led_release,
    .read    = gpio_led_read,
    .write   = gpio_led_write,
};

static int __init gpio_led_init(void) {
    int ret;

    // 1. 动态分配设备号
    ret = alloc_chrdev_region(&gpio_led_dev_num, GPIO_LED_MINOR,
                              GPIO_LED_CNT, "gpio_led");
    if (ret < 0) {
        pr_err("gpio_led: alloc_chrdev_region failed\n");
        return ret;
    }
    pr_info("gpio_led: major=%d minor=%d\n",
            MAJOR(gpio_led_dev_num), MINOR(gpio_led_dev_num));

    // 2. 初始化cdev并绑定fops
    cdev_init(&gpio_led_cdev, &gpio_led_fops);
    gpio_led_cdev.owner = THIS_MODULE;

    // 3. 添加cdev到内核
    ret = cdev_add(&gpio_led_cdev, gpio_led_dev_num, GPIO_LED_CNT);
    if (ret < 0) {
        pr_err("gpio_led: cdev_add failed\n");
        goto err_cdev_add;
    }

    // 4. 创建设备类
    gpio_led_class = class_create(THIS_MODULE, "gpio_led_class");
    if (IS_ERR(gpio_led_class)) {
        ret = PTR_ERR(gpio_led_class);
        goto err_class_create;
    }

    // 5. 创建设备节点（udev自动生成/dev/gpio_led）
    gpio_led_device = device_create(gpio_led_class, NULL,
                                    gpio_led_dev_num, NULL, "gpio_led");
    if (IS_ERR(gpio_led_device)) {
        ret = PTR_ERR(gpio_led_device);
        goto err_device_create;
    }

    pr_info("gpio_led: driver initialized successfully\n");
    return 0;

err_device_create:
    class_destroy(gpio_led_class);
err_class_create:
    cdev_del(&gpio_led_cdev);
err_cdev_add:
    unregister_chrdev_region(gpio_led_dev_num, GPIO_LED_CNT);
    return ret;
}

static void __exit gpio_led_exit(void) {
    device_destroy(gpio_led_class, gpio_led_dev_num);
    class_destroy(gpio_led_class);
    cdev_del(&gpio_led_cdev);
    unregister_chrdev_region(gpio_led_dev_num, GPIO_LED_CNT);
    pr_info("gpio_led: driver exited\n");
}

module_init(gpio_led_init);
module_exit(gpio_led_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Linux Driver Expert");
MODULE_DESCRIPTION("Character device driver framework example for GPIO LED");

编译与测试：

# 编译驱动
make -C /lib/modules/$(uname -r)/build M=$(pwd) modules

# 加载驱动
sudo insmod gpio_led.ko
# 查看设备号
cat /proc/devices | grep gpio_led
# 查看自动创建的设备节点
ls -l /dev/gpio_led

# 测试读写
echo -n -e '\x01' > /dev/gpio_led   # 写入1（点亮LED）
cat /dev/gpio_led                    # 读取当前值

# 卸载驱动
sudo rmmod gpio_led

2.7 常见问题与调试技巧

问题现象	可能原因	解决方案
`open()`返回`-ENODEV`	设备节点主次设备号与注册的不匹配	检查`/proc/devices`和`ls -l /dev/gpio_led`
`write()`返回`-EFAULT`	用户空间缓冲区地址无效	确保使用`copy_from_user`而非`memcpy`
`insmod`失败，`dmesg`无输出	模块初始化函数返回错误	检查`pr_info`是否启用，添加`printk(KERN_DEBUG ...)`
`/dev/gpio_led`未自动创建	udev未运行或规则缺失	手动`mknod`测试，检查`/sys/class/gpio_led_class/`

安全提醒：字符设备驱动运行在内核空间，任何空指针解引用、缓冲区溢出或死锁都会导致整个系统崩溃（kernel panic）。务必在.read和.write中检查用户空间指针的有效性。

2.8 本章小结

字符设备驱动框架的核心三要素：

file_operations：定义驱动支持的文件操作函数，是用户空间与内核空间的接口契约
主次设备号：唯一标识设备与驱动的对应关系，主设备号找驱动，次设备号找实例
设备节点：用户空间访问入口，通过device_create()配合udev自动生成