3. 字符设备驱动框架：cdev结构体、设备号注册与注销、file_operations接口

字符设备是Linux驱动模型中最基础、最常用的设备类型，其核心特征是按字节流顺序访问，典型的字符设备包括串口、GPIO、I2C、SPI以及各类传感器。本章将深入剖析字符设备驱动的三大支柱：cdev结构体（内核中字符设备的抽象）、设备号（用户空间与内核空间的桥梁）以及file_operations接口（系统调用与驱动行为的映射表）。

3.1 字符设备驱动整体架构

字符设备驱动的完整生命周期包含三个关键阶段：设备号分配、cdev初始化与注册、file_operations实现。下图展示了字符设备驱动在Linux内核中的位置与数据流关系：

3.2 设备号：主设备号与次设备号

设备号是字符设备在内核中的唯一标识，由主设备号（major）和次设备号（minor）两部分组成，类型为 dev_t（32位无符号整数）。

3.2.1 设备号操作宏

Linux内核提供了一组宏，用于在 dev_t 与主/次设备号之间进行转换：

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

dev_t devno = MKDEV(major, minor);  /* 将主次设备号合并为dev_t */
int major = MAJOR(devno);           /* 从dev_t中提取主设备号 */
int minor = MINOR(devno);           /* 从dev_t中提取次设备号 */

3.2.2 设备号注册与注销

设备号的注册与注销是字符设备驱动的“入场”与“退场”操作，必须在模块加载/卸载函数中成对出现：

#include <linux/fs.h>

/* 静态分配：已知主设备号 */
int register_chrdev_region(dev_t first, unsigned int count, const char *name);

/* 动态分配：由内核分配主设备号 */
int alloc_chrdev_region(dev_t *dev, unsigned int firstminor, unsigned int count, const char *name);

/* 注销设备号（两者通用） */
void unregister_chrdev_region(dev_t first, unsigned int count);

3.3 cdev结构体：字符设备的内核抽象

struct cdev 是内核用于管理字符设备的核心数据结构，定义在 <linux/cdev.h> 中。每个字符设备在内核中对应一个 cdev 实例。

struct cdev {
    struct kobject kobj;          /* 内嵌的内核对象，用于引用计数 */
    struct module *owner;         /* 指向所属模块，通常设为 THIS_MODULE */
    const struct file_operations *ops;  /* 指向设备操作函数表 */
    struct list_head list;        /* 用于将cdev链接到系统链表 */
    dev_t dev;                    /* 设备号 */
    unsigned int count;           /* 关联的次设备号数量 */
};

3.3.1 cdev的初始化与注册

cdev的初始化有两种方式，推荐使用 cdev_init 配合 cdev_add 的两步法：

#include <linux/cdev.h>

/* 方式一：两步初始化（推荐） */
struct cdev my_cdev;

/* 步骤1：初始化cdev，绑定file_operations */
cdev_init(&my_cdev, &my_fops);
my_cdev.owner = THIS_MODULE;

/* 步骤2：将cdev添加到内核，关联设备号 */
int ret = cdev_add(&my_cdev, devno, count);
if (ret < 0) {
    /* 错误处理 */
}

/* 方式二：一步初始化（较少用） */
struct cdev *cdev_alloc(void);  /* 动态分配cdev */
cdev->ops = &my_fops;
cdev->owner = THIS_MODULE;

3.3.2 cdev的注销

在模块卸载时，必须按照与注册相反的顺序释放资源：

/* 先移除cdev */
cdev_del(&my_cdev);

/* 再注销设备号 */
unregister_chrdev_region(devno, count);

3.4 file_operations接口：系统调用到驱动函数的映射

struct file_operations 是字符设备驱动的“函数跳转表”，定义了用户空间系统调用与内核驱动函数之间的映射关系。当用户程序调用 open()、read()、write()、ioctl() 等函数时，VFS层通过该结构体找到对应的驱动函数并执行。

3.4.1 核心成员函数

3.4.2 典型file_operations实现模板

#include <linux/fs.h>
#include <linux/uaccess.h>  /* copy_to_user / copy_from_user */

/* 设备打开 */
static int my_open(struct inode *inode, struct file *filp)
{
    /* 获取设备私有数据 */
    struct my_device *dev = container_of(inode->i_cdev, struct my_device, cdev);
    filp->private_data = dev;  /* 保存到file结构体 */
    return 0;
}

/* 设备释放 */
static int my_release(struct inode *inode, struct file *filp)
{
    return 0;
}

/* 从设备读取数据 */
static ssize_t my_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
{
    struct my_device *dev = filp->private_data;
    size_t len = min(count, dev->data_len);
    
    if (copy_to_user(buf, dev->data, len))
        return -EFAULT;
    
    *f_pos += len;
    return len;
}

/* 向设备写入数据 */
static ssize_t my_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos)
{
    struct my_device *dev = filp->private_data;
    size_t len = min(count, sizeof(dev->data));
    
    if (copy_from_user(dev->data, buf, len))
        return -EFAULT;
    
    dev->data_len = len;
    *f_pos += len;
    return len;
}

/* 设备控制命令 */
static long my_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
    struct my_device *dev = filp->private_data;
    
    switch (cmd) {
    case MY_IOCTL_SET:
        /* 处理设置命令 */
        break;
    case MY_IOCTL_GET:
        /* 处理获取命令 */
        break;
    default:
        return -ENOTTY;  /* 不支持的命令 */
    }
    return 0;
}

/* 文件操作结构体 */
static const struct file_operations my_fops = {
    .owner          = THIS_MODULE,
    .open           = my_open,
    .release        = my_release,
    .read           = my_read,
    .write          = my_write,
    .unlocked_ioctl = my_ioctl,
};

3.5 完整注册流程与SVG流程图

字符设备驱动的完整注册流程可以归纳为以下步骤，每一步都对应一个内核API调用：

3.6 完整示例代码

以下是一个完整的字符设备驱动框架示例，整合了设备号分配、cdev注册和file_operations实现：

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

#define DEVICE_NAME "my_char_dev"
#define CLASS_NAME  "my_class"

/* 设备私有结构体 */
struct my_device {
    struct cdev cdev;
    char data[256];
    size_t data_len;
};

static struct my_device *my_dev;
static dev_t dev_num;

/* file_operations 实现 */
static int my_open(struct inode *inode, struct file *filp)
{
    struct my_device *dev = container_of(inode->i_cdev, struct my_device, cdev);
    filp->private_data = dev;
    return 0;
}

static int my_release(struct inode *inode, struct file *filp)
{
    return 0;
}

static ssize_t my_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
{
    struct my_device *dev = filp->private_data;
    size_t len = min(count, dev->data_len - (size_t)*f_pos);
    
    if (len == 0) return 0;
    if (copy_to_user(buf, dev->data + *f_pos, len))
        return -EFAULT;
    
    *f_pos += len;
    return len;
}

static ssize_t my_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos)
{
    struct my_device *dev = filp->private_data;
    size_t len = min(count, sizeof(dev->data) - (size_t)*f_pos);
    
    if (copy_from_user(dev->data + *f_pos, buf, len))
        return -EFAULT;
    
    dev->data_len = *f_pos + len;
    *f_pos += len;
    return len;
}

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)
{
    int ret;

    /* 1. 动态分配设备号 */
    ret = alloc_chrdev_region(&dev_num, 0, 1, DEVICE_NAME);
    if (ret < 0) {
        pr_err("Failed to allocate device number\n");
        return ret;
    }
    pr_info("Allocated device number: major=%d, minor=%d\n",
            MAJOR(dev_num), MINOR(dev_num));

    /* 2. 分配设备结构体 */
    my_dev = kzalloc(sizeof(*my_dev), GFP_KERNEL);
    if (!my_dev) {
        unregister_chrdev_region(dev_num, 1);
        return -ENOMEM;
    }

    /* 3. 初始化cdev并注册 */
    cdev_init(&my_dev->cdev, &my_fops);
    my_dev->cdev.owner = THIS_MODULE;
    ret = cdev_add(&my_dev->cdev, dev_num, 1);
    if (ret < 0) {
        pr_err("Failed to add cdev\n");
        kfree(my_dev);
        unregister_chrdev_region(dev_num, 1);
        return ret;
    }

    pr_info("Character device driver loaded successfully\n");
    return 0;
}

/* 模块卸载 */
static void __exit my_exit(void)
{
    cdev_del(&my_dev->cdev);
    kfree(my_dev);
    unregister_chrdev_region(dev_num, 1);
    pr_info("Character device driver unloaded\n");
}

module_init(my_init);
module_exit(my_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Kernel Developer");
MODULE_DESCRIPTION("A simple character device driver example");

3.7 本章小结

字符设备驱动框架是Linux驱动开发的基础，理解其核心三要素至关重要：

• 设备号：用户空间与内核空间的桥梁，推荐使用动态分配避免冲突。
• cdev结构体：字符设备在内核中的抽象，通过 cdev_init + cdev_add 注册，cdev_del 注销。
• file_operations接口：系统调用到驱动函数的映射表，必须实现 .owner = THIS_MODULE。