Linux内核kfifo环形队列深入解析与使用指南
概述
kfifo是Linux内核提供的一种先进先出（FIFO）数据结构，基于环形缓冲区实现。它支持无中断的字节流服务，并且实现了无锁并发访问：当场景中仅有一个写入线程和一个读取线程时，两者可以同时操作而无需使用锁机制，从而保证线程安全。该结构通常用于速度不匹配的通信环节中进行缓冲。
以下是kfifo工作过程的文字描述：
- 初始状态：缓冲区为空，in和out指针指向起始位置。
- 写入数据（put）：
当写入数据时，数据从in指针位置开始填充，in指针向前移动。若写入长度超出缓冲区末尾，剩余部分会从缓冲区首部开始写入（环形特性）。 - 读取数据（get）：
读取操作从out指针位置开始，数据被读取后，out指针前移，释放相应空间。 - 当写入的数据长度超过从in到缓冲区末尾的剩余空间时：
数据的一部分写入末尾，剩余部分绕回到缓冲区头部继续写入（即"回绕"现象）。
重要说明：
- 若仅有单一写入者和单一读取者，则无需加锁，kfifo天然保证线程安全。
- 若存在多个写入者但仅一个读取者，需在写入侧加锁（如自旋锁）。
- 若存在多个读取者但仅一个写入者，则需在读取侧加锁。
内核源码位置：lib/kfifo.c 和 include/linux/kfifo.h。
使用时需包含头文件：
#include <linux/kfifo.h>核心数据结构
struct __kfifo 内部结构
struct __kfifo {
unsigned int in; // 写入索引，指向下一个可存放元素的位置
unsigned int out; // 读取索引，指向下一个待读取元素的位置
unsigned int mask; // 缓冲区大小向上取整为2的幂后，size - 1
unsigned int esize; // 每个元素占用的字节数
void *data; // 指向实际数据缓冲区的指针
};各成员关系示意：
data 指向一块连续内存，in 和 out 通过 mask 进行取模运算，实现环形逻辑（in & mask、out & mask）。
struct kfifo 封装结构
struct kfifo {
union {
struct __kfifo kfifo; // 核心fifo结构
unsigned char *type; // 类型提示，不实际使用
const unsigned char *const_type;
char (*rectype)[0]; // 用于获取record size（若使用record FIFO）
void *ptr;
void const *ptr_const;
};
unsigned char buf[0]; // 静态定义时的内嵌数组
};该联合体的巧妙之处在于：其余成员并不参与实际数据存储，仅在编译期用于类型推断和大小计算。例如：
kfifo_recsize(fifo)通过sizeof(*(fifo)->rectype)获取记录大小。- 在
kfifo_alloc中，通过sizeof(*__tmp->type)获取元素大小。
kfifo的声明与初始化
kfifo支持两种初始化方式：动态分配和静态定义。
动态分配
常用方式：先声明一个 struct kfifo 变量，然后调用 kfifo_alloc 分配缓冲区。
// 方式1：直接定义结构体
struct kfifo my_fifo = {0};
kfifo_alloc(&my_fifo, 4096, GFP_KERNEL);
// 方式2：使用DECLARE_KFIFO_PTR宏
DECLARE_KFIFO_PTR(my_fifo, unsigned char);
INIT_KFIFO(my_fifo);
kfifo_alloc(&my_fifo, 4096, GFP_KERNEL);动态分配的缓冲区在使用完毕后必须调用 kfifo_free 进行释放。
静态定义
在编译时即确定缓冲区大小（需为2的幂），内嵌于结构体中。
// 方式1：DECLARE_KFIFO + INIT_KFIFO
DECLARE_KFIFO(static_fifo, char, 512);
INIT_KFIFO(static_fifo);
// 方式2：DEFINE_KFIFO（一步完成）
DEFINE_KFIFO(static_fifo, char, 512);核心API函数
| 宏/函数 | 说明 |
|---|---|
kfifo_alloc(fifo, size, gfp_mask) | 为指针式FIFO动态分配缓冲区并初始化，返回0成功，负数出错。 |
kfifo_free(fifo) | 释放由 kfifo_alloc 分配的内存。 |
kfifo_in(fifo, buf, n) | 将 buf 中的 n 个元素入队，返回实际入队个数（可能小于 n 如果空间不足）。 |
kfifo_out(fifo, buf, n) | 从FIFO中取出最多 n 个元素存入 buf，返回实际读取个数。 |
kfifo_put(fifo, val) | 将单个元素 val（值传递）入队，返回1成功，0失败（满）。 |
kfifo_get(fifo, val) | 从FIFO中读取一个元素存储到 val（指针）指向的位置，返回1成功，0失败（空）。 |
kfifo_peek(fifo, val) | 与 kfifo_get 类似，但不更新 out 指针。 |
kfifo_out_peek(fifo, buf, n) | 预取 n 个元素到 buf，不移动 out 指针。 |
kfifo_in_spinlocked(fifo, buf, n, lock) | 加锁版本入队，使用 spin_lock_irqsave 保护。 |
kfifo_out_spinlocked(fifo, buf, n, lock) | 加锁版本出队，使用 spin_lock_irqsave 保护。 |
kfifo_from_user(fifo, from, len, copied) | 将用户空间数据复制到FIFO。 |
kfifo_to_user(fifo, to, len, copied) | 将FIFO数据复制到用户空间。 |
kfifo_size(fifo) | 返回FIFO的总大小（元素个数）。 |
kfifo_len(fifo) | 返回当前已存储元素个数。 |
kfifo_avail(fifo) | 返回剩余可用空间（元素个数）。 |
kfifo_is_empty(fifo) | 判断FIFO是否为空（in == out）。 |
kfifo_is_full(fifo) | 判断FIFO是否已满。 |
kfifo_reset(fifo) | 重置in和out为0，需确保并发安全（加锁）。 |
kfifo_reset_out(fifo) | 仅将out设为in，适用于单一读取者场景。 |
使用示例
模式一：动态分配（字节流）
#include <linux/kfifo.h>
#include <linux/module.h>
#include <linux/slab.h>
struct item {
char name[32];
unsigned char value;
};
#define MAX_ITEMS 64
static struct kfifo sample_fifo;
static int __init kfifo_demo_init(void)
{
int ret, i;
struct item data;
// 1. 分配缓冲区（大小需调整为2的幂）
ret = kfifo_alloc(&sample_fifo, sizeof(struct item) * MAX_ITEMS, GFP_KERNEL);
if (ret) {
pr_err("kfifo_alloc failed: %d\n", ret);
return ret;
}
// 2. 入队
for (i = 0; i < MAX_ITEMS; i++) {
snprintf(data.name, sizeof(data.name), "entry_%d", i);
data.value = i;
if (!kfifo_in(&sample_fifo, &data, sizeof(data))) {
pr_warn("fifo full at i=%d\n", i);
break;
}
}
// 3. 出队（先peek再实际取出）
for (i = 0; i < MAX_ITEMS; i++) {
if (!kfifo_out_peek(&sample_fifo, &data, sizeof(data))) {
pr_info("fifo empty, stop\n");
break;
}
// 正式取出（移动out指针）
kfifo_out(&sample_fifo, &data, sizeof(data));
pr_info("read: name=%s, val=%u\n", data.name, data.value);
}
// 4. 释放
kfifo_free(&sample_fifo);
return 0;
}
static void __exit kfifo_demo_exit(void)
{
kfifo_free(&sample_fifo);
}
module_init(kfifo_demo_init);
module_exit(kfifo_demo_exit);
MODULE_LICENSE("GPL");
上述示例中，in/out 指针以字节为单位移动。
模式二：静态定义（元素级操作）
#include <linux/kfifo.h>
#include <linux/module.h>
struct packet {
char tag[16];
int len;
};
#define POOL_SIZE 32 // 必须是2的幂
DECLARE_KFIFO(pkt_fifo, struct packet, POOL_SIZE);
static int __init static_fifo_init(void)
{
int i, ret;
struct packet pkt;
// 1. 初始化
INIT_KFIFO(pkt_fifo);
// 2. 入队（使用kfifo_put）
for (i = 0; i < POOL_SIZE; i++) {
snprintf(pkt.tag, sizeof(pkt.tag), "pkt_%d", i);
pkt.len = i * 10;
if (!kfifo_put(&pkt_fifo, pkt)) {
pr_warn("fifo full\n");
break;
}
}
// 3. 出队（使用kfifo_get）
while (kfifo_get(&pkt_fifo, &pkt)) {
pr_info("got: tag=%s, len=%d\n", pkt.tag, pkt.len);
pr_info("in=%u out=%u\n", pkt_fifo.kfifo.in, pkt_fifo.kfifo.out);
if (kfifo_is_empty(&pkt_fifo)) {
pr_info("fifo now empty\n");
break;
}
}
return 0;
}
static void __exit static_fifo_exit(void)
{
// 静态定义无需释放
}
module_init(static_fifo_init);
module_exit(static_fifo_exit);
MODULE_LICENSE("GPL");
在静态定义模式下，kfifo_put 和 kfifo_get 操作以结构体（元素）为单位，而非字节。
关键点总结
- 大小对齐：无论动态还是静态，缓冲区大小必须为2的幂，否则内核会向上调整。
- 无锁条件：单写入者 + 单读取者时无需加锁；多对一场景需对多的一方加锁。
- 两种操作粒度：
kfifo_in/out以字节为单位，适合通用缓冲；kfifo_put/get以元素为单位，适用于结构体队列。 - 内存管理：动态分配需匹配
kfifo_free；静态定义无需释放。
