Linux字符设备驱动：揭开Linux内核背后的秘密

闲谈

2023-09-21 09:11:41

Linux字符设备驱动：解锁内核与外设的沟通

字符设备驱动是Linux内核中一种重要的驱动模型，负责与逐字符读写的设备（如键盘、鼠标和串口）进行交互。它在人机交互、通信和存储等方面发挥着至关重要的作用。

原理与组成

字符设备驱动采用特定的模型，定义了与内核和字符设备交互的接口。典型的字符设备驱动由以下部分组成：

核心部分： 处理字符设备的输入和输出请求（如读取和写入）
字符设备文件： 虚拟文件，代表字符设备，用户可通过打开和关闭访问设备
设备模型： 定义设备属性和操作（如名称、类型和打开/关闭操作）

实现与接口

字符设备驱动用C语言编写，遵循Linux内核驱动模型。实现过程包括：

注册驱动： 将驱动注册到内核，以便识别和加载
创建设备文件： 创建代表字符设备的虚拟文件
定义设备模型： 指定设备属性和操作
实现核心部分： 处理输入/输出请求

驱动与内核和设备通过接口通信，包括：

打开/关闭接口： 处理设备文件打开/关闭
读/写接口： 进行数据读写操作
ioctl接口： 执行控制操作（如设置参数和获取状态）

代码示例：一个简单的字符设备驱动

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

// 设备名称
#define DEVICE_NAME "my_char_dev"

// 设备的主要结构体
struct my_char_dev {
    char data[100];
    int open_count;
};

// 私有数据结构体，用于存储每个打开实例的数据
struct my_char_dev_private {
    struct my_char_dev *dev;
};

// 打开设备文件
static int my_char_dev_open(struct inode *inode, struct file *file)
{
    struct my_char_dev_private *private;
    private = kmalloc(sizeof(struct my_char_dev_private), GFP_KERNEL);
    if (!private) {
        return -ENOMEM;
    }
    private->dev = container_of(inode->i_cdev, struct my_char_dev, cdev);
    file->private_data = private;
    private->dev->open_count++;
    return 0;
}

// 关闭设备文件
static int my_char_dev_release(struct inode *inode, struct file *file)
{
    struct my_char_dev_private *private = file->private_data;
    kfree(private);
    return 0;
}

// 从设备读取数据
static ssize_t my_char_dev_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
{
    struct my_char_dev_private *private = file->private_data;
    if (count > strlen(private->dev->data)) {
        count = strlen(private->dev->data);
    }
    if (copy_to_user(buf, private->dev->data, count)) {
        return -EFAULT;
    }
    *pos += count;
    return count;
}

// 向设备写入数据
static ssize_t my_char_dev_write(struct file *file, const char __user *buf, size_t count, loff_t *pos)
{
    struct my_char_dev_private *private = file->private_data;
    if (count > sizeof(private->dev->data)) {
        count = sizeof(private->dev->data);
    }
    if (copy_from_user(private->dev->data, buf, count)) {
        return -EFAULT;
    }
    *pos += count;
    return count;
}

// 设备文件操作集
static struct file_operations my_char_dev_fops = {
    .owner = THIS_MODULE,
    .open = my_char_dev_open,
    .release = my_char_dev_release,
    .read = my_char_dev_read,
    .write = my_char_dev_write,
};

// 设备模型
static dev_t my_char_dev_number;
static struct cdev my_char_dev_cdev;

// 初始化模块
static int my_char_dev_init(void)
{
    // 分配设备编号
    if (alloc_chrdev_region(&my_char_dev_number, 0, 1, DEVICE_NAME) < 0) {
        return -1;
    }
    
    // 初始化设备
    cdev_init(&my_char_dev_cdev, &my_char_dev_fops);
    if (cdev_add(&my_char_dev_cdev, my_char_dev_number, 1) < 0) {
        unregister_chrdev_region(my_char_dev_number, 1);
        return -1;
    }
    
    return 0;
}

// 退出模块
static void my_char_dev_exit(void)
{
    // 注销设备
    cdev_del(&my_char_dev_cdev);
    
    // 释放设备编号
    unregister_chrdev_region(my_char_dev_number, 1);
}

module_init(my_char_dev_init);
module_exit(my_char_dev_exit);
MODULE_LICENSE("GPL");