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

程序猿编码2025-09-15 18:40

在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），消费者读取后唤醒

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

cpp 复制代码 
...
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【程序猿编码】

相关推荐
一只游鱼2 小时前
Zookeeper介绍与部署（Linux）
linux·运维·服务器·zookeeper
怎么没有名字注册了啊2 小时前
MFC_Install_Create
c++·mfc
Wadli3 小时前
C++语法 | static静态|单例模式
开发语言·c++·单例模式
wheeldown3 小时前
【Linux】 存储分级的秘密
linux·运维·服务器
天天进步20153 小时前
掌握React状态管理：Redux Toolkit vs Zustand vs Context API
linux·运维·react.js
进击的_鹏3 小时前
【C++11】initializer_list列表初始化、右值引用和移动语义、可变参数模版等
开发语言·c++
艾醒(AiXing-w)3 小时前
探索大语言模型（LLM）：Ollama快速安装部署及使用（含Linux环境下离线安装）
linux·人工智能·语言模型
mark-puls3 小时前
C语言打印爱心
c语言·开发语言·算法
垚垚领先3 小时前
Kdump 文档 - 基于 kexec 的崩溃转储解决方案
linux
热门推荐
01GitHub 镜像站点02UV 工具安装与国内镜像源配置指南03A股预测还能更准？开源大模型Kronos带你跑通预测+回测全流程04KGG转MP3工具|非KGM文件|解密音频0546个Nano-banana 精选提示词，持续更新中06UV安装并设置国内源07conda中设置镜像地址（附所有可换的地址）08突破百度网盘的下载限速，两种方法教会你【超详细】09Spec-Kit 使用指南10保姆级教程：手把手教你用Dify实现完美多轮对话（附Chatflow和提示词）