<think>我们面临的任务是：在Linux内核模块中，通过poll机制和/proc文件系统，实现用户态程序能够读取由内核驱动触发的
中断信息，并进一步读取CPLD寄存器。
整体思路：
1. 创建一个/proc文件，用户态程序可以通过读取这个文件来获取
中断信息。
2. 在驱动中，当
中断发生时，记录
中断信息（例如时间、
中断号等），并唤醒等待队列，以便用户态程序知道有
中断发生。
3. 使用poll机制，使得用户态程序可以阻塞地等待
中断事件，当有
中断发生时，poll会返回，用户态程序可以读取/proc文件获取
中断信息。
4. 用户态程序在读取
中断信息后，可以进一步执行读取CPLD寄存器的操作（这部分在用户态完成，通常通过/dev/mem或sysfs等方式，但这里我们只关注如何通知用户态
中断发生）。
步骤详解（内核模块部分）：
a. 创建/proc文件入口。
b. 实现/proc文件的read、write（如果需要）、poll等操作。
c. 初始化一个等待队列，用于在
中断处理函数和用户态读取进程之间同步。
d. 在
中断处理函数中，记录
中断信息，并唤醒等待队列。
e. 在proc文件的poll操作中，将当前进程加入等待队列，并返回事件掩码（POLLIN表示有数据可读）。
用户态程序：
用户态程序通过poll
()系统调用监视/proc文件，当有
中断发生时，poll返回，然后程序读取/proc文件内容（即
中断信息），然后进行读取CPLD寄存器的操作。
注意：这里我们只实现内核模块中通过/proc文件通知
中断事件，读取CPLD寄存器的操作在用户态完成（具体方法不在本模块中）。
下面我们编写一个示例内核模块：
假设：
- 我们有一个硬件
中断（例如
IRQ号为5），在模块中注册这个
中断。
- 创建/proc/interrupt_event文件。
内核模块代码：</think>### 解决方案：使用 poll + /proc 文件实现
中断通知和 CPLD 寄存器读取
#### 内核模块实现
以下是完整的内核模块代码，实现
中断处理、proc 文件操作和 poll 支持：
```c
#include <linux/module.h>
#include <linux/proc_fs.h>
#include <linux/interrupt.h>
#include <linux/wait.h>
#include <linux/poll.h>
#include <linux/uaccess.h>
#include <linux/fs.h>
#include <linux/sched.h>
#include <linux/io.h>
#define
IRQ_NUM 5 // 硬件
中断号（根据实际修改）
#define PROC_NAME "cpld" // /proc 文件名
// 全局变量
static DECLARE_WAIT_QUEUE_HEAD
(irq_waitq
);
static volatile int
irq_occurred = 0;
static char interrupt_info[128] = {0};
static struct proc_dir_entry *proc_entry;
// 模拟读取 CPLD 寄存器（实际需替换为硬件操作）
static u32 read_cpld_register
(void
) {
// 这里应替换为实际的硬件寄存器读取操作
// 示例：return ioread32
(cpld_base + offset
);
return 0xDEADBEEF; // 返回模拟值
}
//
中断处理函数
static
irqreturn_t
irq_handler
(int
irq, void *dev_id
) {
u32 reg_value = read_cpld_register
(); // 读取CPLD寄存器
// 记录
中断信息（时间戳 + 寄存器值）
snprintf
(interrupt_info, sizeof
(interrupt_info
),
"[%lld]
IRQ %d: CPLD=0x%08X\n",
ktime_get_ns
(),
irq, reg_value
);
irq_occurred = 1; // 设置
中断标志
wake_up_interruptible
(&
irq_waitq
); // 唤醒等待队列
return
IRQ_HANDLED;
}
// proc文件读取函数
static ssize_t proc_read
(struct file *file, char __user *buf, size_t count, loff_t *ppos
) {
if
(*ppos > 0 || !
irq_occurred
)
return 0;
// 将
中断信息复制到用户空间
int len = strlen
(interrupt_info
);
if
(copy_to_user
(buf, interrupt_info, len
))
return -EFAULT;
*ppos = len;
irq_occurred = 0; // 重置
中断标志
return len;
}
// proc文件poll函数
static unsigned int proc_poll
(struct file *file, poll_table *wait
) {
unsigned int mask = 0;
poll_wait
(file, &
irq_waitq, wait
); // 加入等待队列
if
(irq_occurred
)
mask |= POLLIN | POLLRDNORM; // 有数据可读
return mask;
}
// proc文件操作结构体
static struct proc_ops proc_fops = {
.proc_read = proc_read,
.proc_poll = proc_poll,
};
// 模块初始化
static int __init cpld_driver_init
(void
) {
// 注册
中断处理程序
if
(request_
irq(IRQ_NUM,
irq_handler,
IRQF_SHARED, "cpld_
irq", NULL
)) {
printk
(KERN_ERR "Failed to request
IRQ %d\n",
IRQ_NUM
);
return -EIO;
}
// 创建/proc文件
proc_entry = proc_create
(PROC_NAME, 0666, NULL, &proc_fops
);
if
(!proc_entry
) {
free_
irq(IRQ_NUM, NULL
);
return -ENOMEM;
}
printk
(KERN_INFO "CPLD driver loaded.
IRQ:%d\n",
IRQ_NUM
);
return 0;
}
// 模块退出
static void __exit cpld_driver_exit
(void
) {
remove_proc_entry
(PROC_NAME, NULL
);
free_
irq(IRQ_NUM, NULL
);
printk
(KERN_INFO "CPLD driver unloaded\n"
);
}
module_init
(cpld_driver_init
);
module_exit
(cpld_driver_exit
);
MODULE_LICENSE
("GPL"
);
```
#### 用户态程序
用户态程序通过 poll 监控 `/proc/cpld` 文件，读取
中断信息：
```c
#include <stdio.h>
#include <fcntl.h>
#include <poll.h>
#include <unistd.h>
int main
() {
const char *proc_file = "/proc/cpld";
struct poll
fd p
fd = {
.
fd = open
(proc_file, O_RDONLY
),
.events = POLLIN
};
if
(p
fd.
fd < 0
) {
perror
("Open /proc/cpld failed"
);
return 1;
}
while
(1
) {
int ret = poll
(&p
fd, 1, -1
); // 阻塞等待
中断
if
(ret > 0 &&
(p
fd.revents & POLLIN
)) {
char buf[256];
ssize_t len = read
(p
fd.
fd, buf, sizeof
(buf
)-1
);
if
(len > 0
) {
buf[len] = '\0';
printf
("Interrupt received: %s", buf
);
// 这里添加读取CPLD寄存器的实际代码
// 示例：read_cpld_register
();
}
lseek
(p
fd.
fd, 0, SEEK_SET
); // 重置文件指针
} else {
perror
("Poll error"
);
break;
}
}
close(p
fd.
fd);
return 0;
}
```
### 原理解释
1. **
中断处理流程**：
- 硬件
中断触发内核的 `
irq_handler`
-
中断处理中读取 CPLD 寄存器值并记录时间戳
- 设置 `
irq_occurred` 标志并唤醒等待队列
2. **/proc 文件系统**：
- 通过 `proc_create` 创建 `/proc/cpld` 虚拟文件
- `proc_read` 将
中断信息复制到用户空间
- `proc_poll` 实现 poll 的等待机制
3. **poll 同步机制**：
- 用户态调用 poll 阻塞等待
- 内核通过 `poll_wait` 将进程加入等待队列
-
中断发生后 `wake_up_interruptible` 唤醒进程
4. **数据流**：
```mermaid
graph LR
A[硬件
中断] --> B[
中断处理函数]
B --> C[记录寄存器值]
C --> D[设置标志位]
D --> E[唤醒用户进程]
E --> F[用户态读取/proc文件]
F --> G[执行CPLD操作]
```
### 实际应用注意事项
1. **硬件适配**：
- 修改 `
IRQ_NUM` 为实际
中断号
- 在 `read_cpld_register` 中实现真实的寄存器访问（如使用 `ioremap`/`iounmap`）
2. **安全增强**：
- 添加 spinlock 保护共享数据
- 限制 proc 文件最大读取次数
- 实现写操作进行调试控制
3. **性能优化**：
- 使用非阻塞 I/O 减少延迟
- 添加环形缓冲区存储多次
中断
- 支持多用户同时监控
4. **错误处理**：
- 检查
中断注册返回值
- 处理内存分配失败
- 防范用户空间缓冲区溢出
本文探讨了一种特定的Linux内核错误：尝试释放已释放的中断（IRQ）。此问题通常出现在应用程序退出时，由于未能正确管理中断资源而导致。文章提供了解决方案，建议将请求中断（request_irq）的操作从驱动初始化阶段移至如设备打开（open）等其他时机。
扫一扫
400
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
