当前位置： 首页 > news >正文

基于 Linux 内核模块的字符设备 FIFO 驱动设计与实现解析（C/C++代码实现）

news 2025/9/15 5:11:28

在Linux操作系统中，FIFO（命名管道）是一种经典的进程间通信（IPC）机制，它通过文件系统接口提供了可靠的字节流传输能力。本文将深入解析一个基于Linux内核模块实现的字符设备FIFO驱动，探讨其设计思路、核心原理、涉及的内核知识点，以及如何通过内核级编程模拟FIFO的核心功能。

一、核心功能定位：内核模块实现的字符设备FIFO

该内核模块的本质是通过字符设备驱动（/dev接口）模拟FIFO管道的功能，它并非依赖Linux内核原生的pipe/fifo机制，而是从零构建了一套具备“生产者-消费者”同步特性的环形缓冲区通信模型。其核心功能可概括为：

  1. 设备抽象：在/dev目录下创建字符设备文件（如/dev/fifodev），用户进程通过标准的open()/read()/write()/close()系统调用与驱动交互，体验与原生FIFO一致。
  2. 双向同步通信：支持多个“生产者进程”（写入数据）和“消费者进程”（读取数据）并发访问，通过同步机制确保数据不会丢失、覆盖，且进程不会无限阻塞。
  3. SMP安全：适配对称多处理器（SMP）系统，通过内核同步原语避免多CPU核心下的竞态问题，保证驱动在多核心环境下的稳定性。
  4. 跨平台兼容：不仅支持Debian等桌面Linux发行版，还可通过适配Android内核（如Android-x86 Oreo）运行在移动设备上。

二、核心设计思路：生产者-消费者模型的内核级实现

该驱动的设计完全围绕生产者-消费者模型展开——生产者进程向驱动写入数据（填充缓冲区），消费者进程从驱动读取数据（消耗缓冲区）。设计的核心挑战是解决“同步”与“互斥”问题，而驱动通过分层设计清晰地实现了这一模型：

1. 核心组件分层

驱动将功能拆解为“资源层”和“操作层”，各层职责明确，降低耦合度：

层级核心组件职责
资源层环形缓冲区（kfifo）、信号量（semaphore）、设备编号（dev_t）、字符设备结构（cdev）管理驱动依赖的硬件/软件资源，如数据存储、同步原语、设备标识
操作层file_operations结构体（open/read/write/release）实现用户进程与内核的交互接口，将系统调用映射为内核级操作

2. 核心设计目标与解决方案

生产者-消费者模型存在三个核心问题，驱动通过针对性设计逐一解决：

核心问题设计目标解决方案
互斥访问多个进程不能同时修改缓冲区/计数器（如prod_count/cons_count），避免数据混乱使用互斥信号量（mtx）保护“临界区”，确保同一时间只有一个进程进入
空缓冲区阻塞消费者不能读取空缓冲区，需等待生产者写入消费者进程阻塞在“消费者信号量”（sem_cons），生产者写入后唤醒
满缓冲区阻塞生产者不能写入满缓冲区，需等待消费者读取生产者进程阻塞在“生产者信号量”（sem_prod），消费者读取后唤醒

三、关键实现原理：从资源管理到同步机制

...
static int cond_wait(int *prod)
{...aux = (*prod == 0) ? &sem_cons : &sem_prod;counter = (*prod == 0) ? &nr_cons_waiting : &nr_prod_waiting;up(&mtx);if (down_interruptible(aux)){if(down_interruptible(&mtx));*counter = *counter - 1;up(&mtx);return -EINTR;}if (down_interruptible(&mtx)) return -EINTR;return 0;
}/* 在/dev条目处执行open()函数时调用 */
static int fifoproc_open(struct inode *in, struct file *f)
{int isProducer;/* lock */if (down_interruptible(&mtx)) return -EINTR;if (f->f_mode & FMODE_READ){ /* 消费者*/cons_count++;isProducer = 0;/* cond_signal(prod) */if (nr_prod_waiting > 0) {nr_prod_waiting--;up(&sem_prod);}while (prod_count == 0){nr_cons_waiting++;if (cond_wait(&isProducer)) return -EINTR;}}else { /* 生产者*/prod_count++;isProducer = 1;if (nr_cons_waiting > 0){nr_cons_waiting--;up(&sem_cons);}while (cons_count == 0){nr_prod_waiting++;if (cond_wait(&isProducer)) return -EINTR;}}/* unlock */up(&mtx);return 0;
}/* 在 /dev 条目执行 close() 函数时调用 */
static int fifoproc_release(struct inode *i, struct file *f)
{if (down_interruptible(&mtx)) return -EINTR;if (f->f_mode & FMODE_READ){ /* 消费者 */cons_count--;if (nr_prod_waiting > 0){ nr_prod_waiting--;up(&sem_prod);}}else { /* 生产者 */prod_count--;if (nr_cons_waiting > 0){nr_cons_waiting--;up(&sem_cons);}}if (prod_count == 0 && cons_count == 0) kfifo_reset(&cbuffer);up(&mtx);return 0;
}/* 在 /dev 条目执行 read() 操作时调用 */
static ssize_t fifoproc_read(struct file *f, char *buff, size_t size, loff_t *l)
{...if (down_interruptible(&mtx)) return -EINTR;while (kfifo_len(&cbuffer) == 0 && prod_count > 0){nr_cons_waiting++;if(cond_wait(&isProducer)) return -EINTR;}if (kfifo_is_empty(&cbuffer)){up(&mtx);return 0;}len = (size >= kfifo_len(&cbuffer))? kfifo_len(&cbuffer) : size;len = kfifo_out(&cbuffer, kbuffer, len);if (nr_prod_waiting > 0){--nr_prod_waiting;up(&sem_prod);}/*unlock */up(&mtx);if (copy_to_user(buff,kbuffer,len)) return -ENOMEM;return len;
}/* 在/dev条目执行write()函数时调用 */
static ssize_t fifoproc_write(struct file *f,const char *buff, size_t size, loff_t *l)
{char kbuffer[MAX_KBUF];int isProducer = 1;if (size > MAX_KBUF) return -ENOMEM;if (copy_from_user(kbuffer, buff,size)) return -ENOMEM;/* lock */if (down_interruptible(&mtx)) return -EINTR;while (kfifo_avail(&cbuffer) < size && cons_count > 0){nr_prod_waiting++;if(cond_wait(&isProducer)) return -EINTR;}kfifo_in(&cbuffer, kbuffer,size);if (cons_count == 0) {up(&mtx);return -EPIPE;}if (nr_cons_waiting > 0){--nr_cons_waiting;up(&sem_cons);}up(&mtx);return size;
}const struct file_operations fops = {.read    =    fifoproc_read,.open    =    fifoproc_open,.write   =    fifoproc_write,.release =    fifoproc_release,
};int modulo_fifo_init(void)
{...if ((ret = alloc_chrdev_region(&start, 0, 1, DEVICE_NAME)) || (kfifo_alloc(&cbuffer, MAX_CBUFFER_LEN, GFP_KERNEL))) {ret = -ENOMEM;printk(KERN_INFO "Couldn't create the /dev entry \n");}else {if((chardev = cdev_alloc()) == NULL) return -ENOMEM;cdev_init(chardev,&fops);if((ret = cdev_add(chardev,start,1))) return -ENOMEM;major = MAJOR(start);minor = MINOR(start);sema_init(&mtx,1);sema_init(&sem_prod, 0); /* 作为等待队列 */sema_init(&sem_cons, 0);printk(KERN_INFO "Module %s charged: major = %d, minor = %d\n", DEVICE_NAME,major,minor);}return ret;
}void modulo_fifo_exit(void) 
{if (chardev) cdev_del(chardev);/* 注销该设备 */unregister_chrdev_region(start, 1);kfifo_free(&cbuffer);printk(KERN_INFO "Module %s disconnected \n", DEVICE_NAME);
}module_init(modulo_fifo_init);
module_exit(modulo_fifo_exit);

If you need the complete source code, please add the WeChat number (c17865354792)

1. 数据存储：环形缓冲区（kfifo）的选择与优势

驱动没有使用普通数组存储数据，而是采用内核提供的kfifo（环形缓冲区）结构，这是内核编程中处理“流式数据”的经典选择，其核心优势在于：

  • 无锁操作（部分场景）：kfifo的kfifo_in()（写入）和kfifo_out()（读取）接口在单生产者-单消费者场景下可无锁使用，减少同步开销；若多生产者/多消费者，配合外部互斥锁（如mtx）即可保证安全。
  • 自动循环：缓冲区满时自动覆盖旧数据（需配合同步机制避免），空时返回“无数据”标识，无需手动管理缓冲区指针（如head/tail），简化代码。
  • 内核原生支持：kfifo是Linux内核的标准数据结构（定义在<linux/kfifo.h>），支持动态分配（kfifo_alloc()）、释放（kfifo_free()）、重置（kfifo_reset()），兼容性和稳定性有保障。

本驱动中kfifo的大小被定义为MAX_CBUFFER_LEN = 64字节，即最多可缓存64字节数据，超过则需等待消费者读取。

2. 同步机制：信号量（semaphore）的双重角色

驱动使用了三类信号量，分别承担“互斥”和“条件等待”的角色，这是内核级同步的经典用法：

（1）互斥信号量（mtx）：保护临界区
  • 初始化：通过sema_init(&mtx, 1)初始化，初始值为1——这是信号量作为“互斥锁”的典型配置（值为1表示“资源可用”，值为0表示“资源被占用”）。
  • 作用：所有修改“共享资源”的操作（如修改prod_count/cons_count、读写kfifo、修改等待进程计数器nr_prod_waiting）都必须在“临界区”内执行，即通过down_interruptible(&mtx)（加锁）和up(&mtx)（解锁）包裹。
  • SMP安全保障：在SMP系统中，semaphore会通过CPU核心间的内存屏障（memory barrier）确保共享数据的可见性，避免“缓存不一致”导致的竞态问题。
（2）条件信号量（sem_prod/sem_cons）：实现进程等待与唤醒

这两个信号量初始值均为0（sema_init(&sem_prod, 0)），作用是模拟“条件变量”（condition variable），实现进程的阻塞与唤醒：

  • sem_prod（生产者信号量）：生产者进程因缓冲区满而阻塞时，会等待该信号量；当消费者读取数据后，会唤醒该信号量上的生产者。
  • sem_cons（消费者信号量）：消费者进程因缓冲区空而阻塞时，会等待该信号量；当生产者写入数据后，会唤醒该信号量上的消费者。
（3）自定义条件等待函数（cond_wait()）：模拟内核cond_wait()

驱动实现了cond_wait()函数，其核心逻辑与内核原生cond_wait()（条件等待）一致，解决“先解锁再阻塞”的关键问题：

  1. 首先释放互斥锁（up(&mtx)）：避免进程持有锁阻塞，导致其他进程无法进入临界区（死锁）。
  2. 阻塞在条件信号量上（down_interruptible(aux)）：进程进入睡眠状态，等待被唤醒（不会占用CPU资源）。
  3. 被唤醒后重新加锁（down_interruptible(&mtx)）：确保后续操作仍在临界区内，避免竞态。

同时，cond_wait()还处理了“中断唤醒”（如进程收到SIGINT信号），返回-EINTR告知用户进程“操作被中断”，符合Linux系统调用的行为规范。

3. 设备生命周期管理：从模块加载到卸载

驱动作为内核模块，其生命周期由module_init()和module_exit()函数管理，对应“加载模块”和“卸载模块”两个操作，核心流程如下：

（1）模块加载（modulo_fifo_init()）：资源初始化
  1. 分配设备编号：通过alloc_chrdev_region()动态分配字符设备的“主设备号+次设备号”（dev_t start），避免手动指定主设备号导致的冲突。
  2. 初始化环形缓冲区：通过kfifo_alloc()分配64字节的kfifo缓冲区，用于存储数据。
  3. 初始化字符设备：
    • 调用cdev_alloc()分配cdev结构体（字符设备的核心描述符）；
    • 调用cdev_init()将cdev与file_operations（用户操作接口）绑定；
    • 调用cdev_add()将cdev注册到内核，完成字符设备与设备编号的关联。
  4. 初始化同步原语：初始化mtx（互斥锁）、sem_prod/sem_cons（条件信号量），以及进程计数器（prod_count/cons_count）和等待计数器（nr_prod_waiting/nr_cons_waiting）。
（2）模块卸载（modulo_fifo_exit()）：资源回收
  1. 删除字符设备：调用cdev_del()从内核中移除cdev结构体，释放字符设备资源。
  2. 注销设备编号：调用unregister_chrdev_region()将分配的设备编号归还给内核，避免资源泄漏。
  3. 释放缓冲区：调用kfifo_free()释放kfifo占用的内存。

4. 用户交互接口：file_operations的核心逻辑

file_operations结构体是用户进程与内核驱动的“桥梁”，驱动通过实现其中的关键函数，将用户的系统调用转化为内核级操作：

（1）open()：进程身份识别与同步唤醒

用户进程调用open()打开/dev/fifodev时，驱动会先判断进程身份（生产者/消费者），再通过同步机制确保“生产者-消费者配对”：

  • 消费者（读模式，FMODE_READ）：

    1. 递增cons_count（消费者计数）；
    2. 若有等待的生产者，唤醒一个（通过up(&sem_prod)）；
    3. 若当前无生产者（prod_count == 0），阻塞自身（等待生产者出现）。

  • 生产者（写模式，FMODE_WRITE）：

    1. 递增prod_count（生产者计数）；
    2. 若有等待的消费者，唤醒一个（通过up(&sem_cons)）；
    3. 若当前无消费者（cons_count == 0），阻塞自身（等待消费者出现）。
（2）read()：消费者读取数据

用户进程调用read()时，驱动的核心逻辑是“确保有数据可读，再读取并唤醒生产者”：

  1. 若缓冲区为空且仍有生产者，阻塞消费者（等待数据写入）；
  2. 若缓冲区为空且无生产者，返回0（表示“无更多数据”，类似原生FIFO的“写端关闭”）；
  3. 读取缓冲区数据（kfifo_out()），读取长度为“请求长度”与“缓冲区可用数据长度”的较小值；
  4. 唤醒一个等待的生产者（若存在），告知“缓冲区有空闲空间”；
  5. 通过copy_to_user()将内核缓冲区数据拷贝到用户空间（用户进程的buff）。
（3）write()：生产者写入数据

用户进程调用write()时，驱动的核心逻辑是“确保缓冲区有空间，再写入并唤醒消费者”：

  1. 若请求写入长度超过用户缓冲区上限（MAX_KBUF = 36字节），返回-ENOMEM（内存不足）；
  2. 通过copy_from_user()将用户空间数据拷贝到内核缓冲区（kbuffer）；
  3. 若缓冲区空间不足且仍有消费者，阻塞生产者（等待数据读取）；
  4. 写入数据到kfifo（kfifo_in()）；
  5. 若当前无消费者，返回-EPIPE（管道破裂，类似原生FIFO的“读端关闭”）；
  6. 唤醒一个等待的消费者（若存在），告知“缓冲区有数据可读”。
（4）release()：进程退出与资源清理

用户进程调用close()关闭设备时，驱动会更新计数并清理资源：

  1. 递减对应计数器（cons_count或prod_count）；
  2. 唤醒等待的对立进程（如消费者退出时唤醒生产者，避免生产者无限阻塞）；
  3. 若最后一个进程退出（prod_count == 0 && cons_count == 0），重置kfifo（清空缓冲区），为下一轮访问做准备。

四、相关领域知识点：内核编程与同步原语

理解该驱动需要掌握Linux内核编程的核心知识点，这些知识点也是内核开发的基础：

1. 字符设备驱动框架

字符设备是Linux内核中最基础的设备类型（如串口、键盘、FIFO），其核心框架包括：

  • 设备编号（dev_t）：由“主设备号”（标识驱动）和“次设备号”（标识同一驱动下的多个设备）组成，通过alloc_chrdev_region()动态分配或register_chrdev_region()静态注册。
  • cdev结构体：字符设备的核心描述符，包含设备的操作接口（file_operations）和私有数据，通过cdev_init()和cdev_add()注册到内核。
  • file_operations结构体：定义用户进程可对设备执行的操作（如read/write/open），是用户空间与内核空间的“接口契约”。

2. 内核同步原语

内核编程中，“同步”是避免竞态（race condition）的关键，常用同步原语包括：

原语作用适用场景
信号量（semaphore）实现互斥（值为1）或计数同步（值为N）多进程/线程间的互斥与等待唤醒，支持中断唤醒
互斥锁（mutex）严格的互斥（同一时间只有一个持有者）比信号量更轻量，适合短时间的临界区保护
条件变量（cond_var）配合互斥锁实现“条件等待”需等待某个条件满足（如缓冲区非空）时使用
自旋锁（spinlock）忙等（busy-wait）式互斥，不睡眠适合SMP系统中极短时间的临界区，避免进程切换开销

本驱动使用信号量同时实现“互斥”和“条件等待”，是一种经典且兼容性强的方案（早期内核中条件变量支持较弱，信号量是常用替代方案）。

3. 内核空间与用户空间的数据交互

内核空间与用户空间是隔离的（内存保护机制），不能直接访问对方的内存，需通过内核提供的专用函数：

  • copy_to_user(dst, src, len)：将内核空间数据（src）拷贝到用户空间（dst），返回0表示成功，非0表示拷贝失败（如用户空间地址非法）。
  • copy_from_user(dst, src, len)：将用户空间数据（src）拷贝到内核空间（dst），返回值含义与copy_to_user()一致。

这两个函数会处理“页面异常”（如用户空间地址未映射），并确保数据传输的安全性，是内核编程中必须遵守的规范（直接访问用户空间地址会导致内核崩溃）。

五、总结

该字符设备FIFO驱动的设计，是Linux内核编程中“生产者-消费者模型”与“字符设备框架”结合的典型案例，其核心价值在于：

  1. 教学价值：清晰展示了内核同步原语、字符设备驱动、数据交互等核心知识点的实际应用，是学习内核编程的优秀范例。
  2. 灵活性：相比原生FIFO，自定义驱动可灵活扩展功能（如添加数据加密、流量控制、日志记录等），满足特殊场景需求。
  3. 跨平台适配：通过适配不同内核版本（如Linux桌面版、Android内核），可在多平台上提供统一的FIFO通信接口。

可能的扩展方向

  • 支持多缓冲区：当前仅一个64字节缓冲区，可扩展为多缓冲区队列，提升并发处理能力。
  • 添加IO控制（ioctl）：通过ioctl()接口允许用户进程动态调整缓冲区大小、设置超时时间等。
  • 替换为更高效的同步原语：在现代内核中，可将“信号量+自定义等待”替换为原生struct completion或条件变量，减少代码复杂度并提升性能。
  • 添加统计功能：记录数据传输量、阻塞次数、唤醒次数等统计信息，方便问题排查与性能优化。

Welcome to follow WeChat official account【程序猿编码】


文章转载自：

http://vVXx5HFl.bLsfz.cn
http://VAMkAwrN.bLsfz.cn
http://C4M2My0r.bLsfz.cn
http://i2cC6i39.bLsfz.cn
http://wvd0ZJ6h.bLsfz.cn
http://EWIysBge.bLsfz.cn
http://0WkaroyY.bLsfz.cn
http://JbSLQEyv.bLsfz.cn
http://Voafvk2a.bLsfz.cn
http://G62TM7Av.bLsfz.cn
http://JNF8Nlgj.bLsfz.cn
http://HcF7BbdX.bLsfz.cn
http://Pzn492Kf.bLsfz.cn
http://MAmWggBs.bLsfz.cn
http://QsSXXrLO.bLsfz.cn
http://GbtZgOZs.bLsfz.cn
http://JUDlKLJe.bLsfz.cn
http://nIbL0u3B.bLsfz.cn
http://srhWFdB5.bLsfz.cn
http://3joZJp8Z.bLsfz.cn
http://rXMRvpfK.bLsfz.cn
http://zEi7PQgC.bLsfz.cn
http://QobxQcsN.bLsfz.cn
http://KbuhIAqa.bLsfz.cn
http://NSVgSDjX.bLsfz.cn
http://3N3tpvcQ.bLsfz.cn
http://emZeBtYH.bLsfz.cn
http://3MugiPAc.bLsfz.cn
http://1RQUewUJ.bLsfz.cn
http://hANsV6DP.bLsfz.cn
http://www.dtcms.com/a/382753.html

相关文章：

  • 【C++】类和对象（下）：初始化列表、类型转换、Static、友元、内部类、匿名对象/有名对象、优化
  • JSON、Ajax
  • 第2课：Agent系统架构与设计模式
  • Python上下文管理器进阶指南：不仅仅是with语句
  • Entities - Entity 的创建模式
  • 用html5写王者荣耀之王者坟墓的游戏2deepseek版
  • 【Wit】pure-admin后台管理系统前端与FastAPI后端联调通信实例
  • godot+c#使用godot-sqlite连接数据库
  • 【pure-admin】pureadmin的登录对接后端
  • tcpump | 深入探索网络抓包工具
  • scikit-learn 分层聚类算法详解
  • Kafka面试精讲 Day 18：磁盘IO与网络优化
  • javaweb CSS
  • css`min()` 、`max()`、 `clamp()`
  • 超越平面交互：SLAM技术如何驱动MR迈向空间计算时代？诠视科技以算法引领变革
  • Win11桌面的word文件以及PPT文件变为白色，但是可以正常打开，如何修复
  • 【系统架构设计（31）】操作系统下：存储、设备与文件管理
  • Flask学习笔记(三)--URL构建与模板的使用
  • 基于单片机的电子抢答器设计（论文+源码）
  • TCP与UDP
  • 【WebSocket✨】入门之旅（六）：WebSocket 与其他实时通信技术的对比
  • 华为防火墙隧道配置
  • 使用 Matplotlib 让排序算法动起来：可视化算法执行过程的技术详解
  • 【C++深学日志】C++编程利器：缺省参数、函数重载、引用详解
  • 晶体管：从基础原理、发展历程到前沿应用与未来趋势的深度剖析
  • CentOS7 安装 Jumpserver 3.10.15
  • jquery 文件上传 （CVE-2018-9207）漏洞复现
  • QML Charts组件之折线图的鼠标交互
  • 工程机械健康管理物联网系统：AIoT技术赋能装备全生命周期智能运维​
  • 第5课：上下文管理与状态持久化