2. Linux 字符设备驱动基础回顾：file_operations 结构体、cdev 注册、设备号分配、简单的 open/read/write 实现

在深入阻塞与非阻塞 I/O 及 poll 机制之前，必须牢固掌握字符设备驱动的核心骨架。本章将系统回顾 file_operations 结构体、cdev 注册流程、设备号分配以及最基本的 open/read/write 实现。这些基础组件是后续所有高级 I/O 模型的基石。

2.1 字符设备驱动核心数据结构

字符设备驱动的灵魂是 struct file_operations，它定义了用户空间系统调用与内核驱动函数之间的映射关系。每个打开的设备文件在内核中都对应一个 struct file 实例，而 struct inode 则代表底层的设备节点。

2.1.1 file_operations 结构体成员速查

2.2 设备号分配：静态 vs 动态

每个字符设备在内核中由 主设备号（Major Number）和 次设备号（Minor Number）唯一标识。主设备号对应驱动程序，次设备号对应具体的设备实例。

2.2.1 设备号分配方式对比

2.2.2 设备号操作宏

#include <linux/fs.h>
#include <linux/kdev_t.h>

// 从主/次设备号合成 dev_t
dev_t dev = MKDEV(major, minor);

// 从 dev_t 提取主设备号
int major = MAJOR(dev);

// 从 dev_t 提取次设备号
int minor = MINOR(dev);

2.3 cdev 结构体与注册流程

struct cdev 是内核中表示字符设备的对象。驱动必须初始化一个 cdev 实例并将其添加到内核的设备表中。

2.3.1 cdev 注册标准步骤

1. 分配设备号：使用 alloc_chrdev_region() 或 register_chrdev_region()。
2. 初始化 cdev：调用 cdev_init()，绑定 file_operations 结构体。
3. 添加 cdev 到内核：调用 cdev_add()，将设备与设备号关联。
4. 创建设备节点：手动 mknod 或使用 device_create() 自动创建（需配合类）。

2.3.2 典型注册代码模板

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

static dev_t dev_num;
static struct cdev my_cdev;
static struct class *my_class;

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

static int __init my_init(void)
{
    // 1. 动态分配设备号
    alloc_chrdev_region(&dev_num, 0, 1, "my_device");
    
    // 2. 初始化 cdev
    cdev_init(&my_cdev, &my_fops);
    my_cdev.owner = THIS_MODULE;
    
    // 3. 添加 cdev 到内核
    cdev_add(&my_cdev, dev_num, 1);
    
    // 4. 创建 device class 和 device（自动生成 /dev/my_device）
    my_class = class_create(THIS_MODULE, "my_class");
    device_create(my_class, NULL, dev_num, NULL, "my_device");
    
    return 0;
}

static void __exit my_exit(void)
{
    device_destroy(my_class, dev_num);
    class_destroy(my_class);
    cdev_del(&my_cdev);
    unregister_chrdev_region(dev_num, 1);
}

module_init(my_init);
module_exit(my_exit);

2.4 简单的 open/read/write 实现

以下是一个基于内核缓冲区的虚拟字符设备实现，展示了最基础的读写操作。该实现使用一个简单的环形缓冲区或固定数组来模拟设备数据。

2.4.1 驱动内部数据结构

#define BUF_SIZE 1024

struct my_device_data {
    char buffer[BUF_SIZE];
    int head;
    int tail;
    struct mutex lock;
};

static struct my_device_data *dev_data;

2.4.2 open 与 release 实现

static int my_open(struct inode *inode, struct file *filp)
{
    // 将私有数据指针存入 filp->private_data
    filp->private_data = dev_data;
    return 0;
}

static int my_release(struct inode *inode, struct file *filp)
{
    // 清理工作（本例中无特殊操作）
    return 0;
}

2.4.3 read 实现（阻塞版本）

static ssize_t my_read(struct file *filp, char __user *buf,
                       size_t count, loff_t *f_pos)
{
    struct my_device_data *data = filp->private_data;
    ssize_t ret;
    
    mutex_lock(&data->lock);
    
    // 计算可读字节数
    size_t available = data->head - data->tail;
    if (available == 0) {
        mutex_unlock(&data->lock);
        return 0;  // 无数据可读
    }
    
    size_t to_read = min(count, available);
    
    // 从内核缓冲区拷贝到用户空间
    if (copy_to_user(buf, data->buffer + data->tail, to_read)) {
        mutex_unlock(&data->lock);
        return -EFAULT;
    }
    
    data->tail += to_read;
    *f_pos += to_read;
    
    mutex_unlock(&data->lock);
    return to_read;
}

2.4.4 write 实现（阻塞版本）

static ssize_t my_write(struct file *filp, const char __user *buf,
                        size_t count, loff_t *f_pos)
{
    struct my_device_data *data = filp->private_data;
    ssize_t ret;
    
    mutex_lock(&data->lock);
    
    // 计算剩余空间
    size_t space = BUF_SIZE - (data->head - data->tail);
    if (space == 0) {
        mutex_unlock(&data->lock);
        return -ENOSPC;  // 缓冲区满
    }
    
    size_t to_write = min(count, space);
    
    // 从用户空间拷贝到内核缓冲区
    if (copy_from_user(data->buffer + data->head, buf, to_write)) {
        mutex_unlock(&data->lock);
        return -EFAULT;
    }
    
    data->head += to_write;
    *f_pos += to_write;
    
    mutex_unlock(&data->lock);
    return to_write;
}

2.5 字符设备驱动整体架构图

下图展示了用户空间、VFS 层、字符设备驱动核心以及硬件之间的完整调用链路与数据流关系。

2.6 本章核心要点总结