4. 字符设备驱动基础

字符设备是Linux驱动模型中最基础、最常用的设备类型，其特点是数据按字节流顺序访问，如串口、键盘、触摸屏等。本章将系统讲解字符设备驱动的核心要素：设备号的分配与管理、file_operations结构体的实现、cdev对象的生命周期管理，并最终完成一个完整的虚拟字符设备驱动。

4.1 设备号：主设备号与次设备号

设备号是内核标识设备的唯一数字，由主设备号（major）和次设备号（minor）两部分组成，共32位。主设备号标识设备对应的驱动程序，次设备号标识由同一驱动管理的具体设备实例。

内核使用dev_t类型（32位无符号整数）存储设备号，并提供宏操作：

#include <linux/types.h>

dev_t dev;                     // 设备号变量
int major = MAJOR(dev);        // 从dev_t提取主设备号
int minor = MINOR(dev);        // 从dev_t提取次设备号
dev = MKDEV(major, minor);     // 由主次设备号合成dev_t

4.1.1 设备号分配策略

设备号分配分为静态分配和动态分配两种方式：

• 静态分配：调用register_chrdev_region()，需开发者手动指定主设备号。适用于已知且未被占用的设备号，但容易与已有驱动冲突。
• 动态分配：调用alloc_chrdev_region()，由内核自动分配未使用的主设备号。推荐用于大多数场景，避免设备号冲突。

// 静态分配：注册0~3号次设备，共4个设备
if (register_chrdev_region(MKDEV(240, 0), 4, "my_device") < 0) {
    pr_err("Failed to register region\n");
    return -EIO;
}

// 动态分配：内核自动分配主设备号，从0号次设备开始，共2个设备
dev_t dev;
if (alloc_chrdev_region(&dev, 0, 2, "my_dynamic_device") < 0) {
    pr_err("Failed to alloc region\n");
    return -EIO;
}
pr_info("Allocated major=%d minor=%d\n", MAJOR(dev), MINOR(dev));

4.1.2 设备号注销

驱动卸载时，必须释放已分配的设备号：

void unregister_chrdev_region(dev_t from, unsigned count);

参数from为起始设备号，count为要注销的设备数量，必须与注册时一致。

4.2 file_operations结构体

file_operations是字符设备驱动的核心接口，它将用户空间的系统调用（如open、read、write）映射到驱动实现的回调函数。该结构体定义在<linux/fs.h>中。

典型实现示例：

static int my_open(struct inode *inode, struct file *filp) {
    pr_info("Device opened\n");
    return 0;
}

static int my_release(struct inode *inode, struct file *filp) {
    pr_info("Device closed\n");
    return 0;
}

static ssize_t my_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos) {
    char kernel_buf[128] = "Hello from kernel!\n";
    size_t len = strlen(kernel_buf);
    if (count < len) len = count;
    if (copy_to_user(buf, kernel_buf, 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) {
    char kernel_buf[128];
    if (count > sizeof(kernel_buf)) count = sizeof(kernel_buf);
    if (copy_from_user(kernel_buf, buf, count)) return -EFAULT;
    pr_info("Received %zu bytes: %s\n", count, kernel_buf);
    *f_pos += count;
    return count;
}

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

4.3 cdev结构体：注册与注销

cdev是内核中表示字符设备的核心结构体，定义在<linux/cdev.h>。每个字符设备在内核中对应一个cdev实例，通过它将设备号与file_operations绑定。

4.3.1 cdev生命周期

#include <linux/cdev.h>

struct cdev my_cdev;          // 静态分配
dev_t dev_num;                // 设备号

// 步骤1+2：初始化cdev
cdev_init(&my_cdev, &my_fops);
my_cdev.owner = THIS_MODULE;

// 步骤3：添加cdev到内核
if (cdev_add(&my_cdev, dev_num, 1) < 0) {
    pr_err("Failed to add cdev\n");
    unregister_chrdev_region(dev_num, 1);
    return -EIO;
}

// 步骤4：模块卸载时删除cdev
cdev_del(&my_cdev);
unregister_chrdev_region(dev_num, 1);

4.4 完整字符设备驱动实现

下面实现一个完整的虚拟字符设备驱动，支持open、release、read、write操作，使用动态设备号分配。

4.4.1 驱动代码

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

#define DEVICE_NAME "vchard"
#define BUFFER_SIZE 1024

static struct cdev vchard_cdev;
static dev_t vchard_dev;
static char *vchard_buffer;
static int vchard_major;

static int vchard_open(struct inode *inode, struct file *filp) {
    pr_info("vchard: device opened\n");
    return 0;
}

static int vchard_release(struct inode *inode, struct file *filp) {
    pr_info("vchard: device closed\n");
    return 0;
}

static ssize_t vchard_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos) {
    size_t available = strlen(vchard_buffer);
    if (*f_pos >= available) return 0;
    if (count > available - *f_pos) count = available - *f_pos;
    if (copy_to_user(buf, vchard_buffer + *f_pos, count)) return -EFAULT;
    *f_pos += count;
    return count;
}

static ssize_t vchard_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos) {
    if (count > BUFFER_SIZE - 1) count = BUFFER_SIZE - 1;
    if (copy_from_user(vchard_buffer, buf, count)) return -EFAULT;
    vchard_buffer[count] = '\0';
    *f_pos += count;
    pr_info("vchard: wrote %zu bytes\n", count);
    return count;
}

static struct file_operations vchard_fops = {
    .owner   = THIS_MODULE,
    .open    = vchard_open,
    .release = vchard_release,
    .read    = vchard_read,
    .write   = vchard_write,
};

static int __init vchard_init(void) {
    // 1. 动态分配设备号
    if (alloc_chrdev_region(&vchard_dev, 0, 1, DEVICE_NAME) < 0) {
        pr_err("vchard: failed to alloc region\n");
        return -EIO;
    }
    vchard_major = MAJOR(vchard_dev);
    pr_info("vchard: major=%d\n", vchard_major);

    // 2. 分配缓冲区
    vchard_buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL);
    if (!vchard_buffer) {
        unregister_chrdev_region(vchard_dev, 1);
        return -ENOMEM;
    }
    memset(vchard_buffer, 0, BUFFER_SIZE);

    // 3. 初始化并添加cdev
    cdev_init(&vchard_cdev, &vchard_fops);
    vchard_cdev.owner = THIS_MODULE;
    if (cdev_add(&vchard_cdev, vchard_dev, 1) < 0) {
        pr_err("vchard: failed to add cdev\n");
        kfree(vchard_buffer);
        unregister_chrdev_region(vchard_dev, 1);
        return -EIO;
    }

    pr_info("vchard: driver loaded successfully\n");
    return 0;
}

static void __exit vchard_exit(void) {
    cdev_del(&vchard_cdev);
    kfree(vchard_buffer);
    unregister_chrdev_region(vchard_dev, 1);
    pr_info("vchard: driver unloaded\n");
}

module_init(vchard_init);
module_exit(vchard_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Kernel Expert");
MODULE_DESCRIPTION("A simple virtual char device driver");

4.4.2 用户空间测试程序

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

int main() {
    char buf[256];
    int fd = open("/dev/vchard0", O_RDWR);
    if (fd < 0) {
        perror("open");
        return 1;
    }

    // 写入数据
    write(fd, "Hello from userspace!", 21);

    // 读取数据
    lseek(fd, 0, SEEK_SET);
    memset(buf, 0, sizeof(buf));
    read(fd, buf, sizeof(buf));
    printf("Read: %s\n", buf);

    close(fd);
    return 0;
}

4.5 常见问题与调试技巧

• 设备节点无法打开：检查设备号是否匹配，使用cat /proc/devices查看已注册的设备号。
• 读写返回-EFAULT：检查copy_to_user/copy_from_user的地址是否正确，用户空间指针不能直接解引用。
• 模块卸载失败：确保没有进程持有设备文件描述符，使用lsof或fuser检查。
• 设备号冲突：优先使用动态分配，避免手动指定已被占用的主设备号。

本章完成了字符设备驱动的完整学习：从设备号分配、file_operations实现、cdev注册注销，到完整的驱动代码与测试。这是后续学习更复杂驱动（如并发控制、阻塞IO、poll机制）的基础。