linux设备驱动阻塞IO应用

1. 驱动中阻塞相关函数的基础

1.1 wait_queue_head_t

定义等待队列头

1. #include <linux/wait.h>
2. /*
3. * lock：自旋锁，用于保护队列操作（如添加/删除等待项）的并发安全
4. * head：链表头，指向等待队列项的链表
5. */
6. typedef struct wait_queue_head {
7.     spinlock_t      lock;
8.     struct list_head    head;
9. } wait_queue_head_t;

复制代码

1.2 init_waitqueue_head

初始化一个已经分配了内存的等待队列头，设置其自旋锁和链表为空

1. void init_waitqueue_head(wait_queue_head_t *q);

复制代码

1.3 DECLARE_WAITQUEUE

静态声明并初始化一个等待队列项（wait queue entry）。该宏创建一个 wait_queue_entry 类型的变量，并将指定的进程描述符 tsk （当前进程为 current ）与该队列项关联，同时设置默认的唤醒函数

1. DECLARE_WAITQUEUE(name, tsk);
3. // 使用方式
4. DECLARE_WAITQUEUE(wait, current);
5. // 展开后为
6. wait_queue_entry_t wait = {
7.     .private    = current,                 // 指向等待的进程 task_struct
8.     .func       = default_wake_function,   // 唤醒时调用的函数
9.     .task_list  = { NULL, NULL }           // 链表节点，用于挂入等待队列头
10. };

复制代码

1.4 add_wait_queue

将一个已经初始化好的等待队列项 wait 添加到等待队列头 queue 所管理的队列中。添加后，该队列项就成为了等待队列的一部分
在进程准备睡眠之前，先将自己添加到等待队列，这样其他唤醒者才能找到它

1. void add_wait_queue(wait_queue_head_t *queue, wait_queue_t *wait);

复制代码

1.5 set_current_state

设置当前进程的状态，将 current->state 赋值为 new_state ，进程状态定义在  中，常见的有：

• TASK_RUNNING：可运行状态（正在运行或就绪）。
  
• TASK_INTERRUPTIBLE：可中断的睡眠状态，可以被信号唤醒。
  
• TASK_UNINTERRUPTIBLE：不可中断的睡眠状态，只能由显式唤醒解除。
  

1. void set_current_state(int new_state);        // 有内存屏障，保证顺序
2. void __set_current_state(int new_state);      // 没有内存屏障   

复制代码

1.6 remove_wait_queue

将之前通过 add_wait_queue 添加的等待队列项从等待队列中移除；当进程被唤醒并重新获得 CPU 后，通常需要调用此函数将自己从等待队列中删除，表示不再等待该条件；如果忘记移除，队列项仍留在等待队列中，可能导致后续不必要的唤醒或资源泄漏

1. void remove_wait_queue(wait_queue_head_t *queue, wait_queue_t *wait);

复制代码

1.7 wake_up

唤醒队列中所有进程（包括 TASK_UNINTERRUPTIBLE和 TASK_INTERRUPTIBLE ）

1. void wake_up(wait_queue_head_t *queue);

复制代码

唤醒等待队列 queue 中所有状态为 TASK_INTERRUPTIBLE 的进程。这些进程将被设置为 TASK_RUNNING 并移入运行队列，等待调度器选择它们运行

1. void wake_up_interruptible(wait_queue_head_t *queue);

复制代码

2. 阻塞驱动使用例子

1. #include <linux/init.h>
2. #include <linux/errno.h>
3. #include <linux/mm.h>
4. #include <linux/sched.h>
5. #include <linux/module.h>
6. #include <linux/ioctl.h>
7. #include <linux/io.h>
8. #include <linux/fs.h>
9. #include <linux/cdev.h>
10. #include <linux/uaccess.h>
11. #include <linux/slab.h>
12. #include <linux/wait.h>
14. #define GLOBALFIFO_SIZE    1024
15. #define GLOBALMEM_MAGIC    'M'
16. #define MEM_CLEAR        _IO(GLOBALMEM_MAGIC, 0)
18. struct globalfifo_dev {
19.     struct cdev m_cdev;            /* 字符设备 */
20.     unsigned int current_len;        /* fifo有效数据长度 */
21.     unsigned char mem[GLOBALFIFO_SIZE];    /* 全局内存 */
22.     struct semaphore sem;            /* 并发控制信号量 */
23.     wait_queue_head_t r_wait;        /* 阻塞读等待队列头 */
24.     wait_queue_head_t w_wait;        /* 阻塞写等待队列头 */
25. };
28. static int globalfifo_major = 266;
30. // 存放字符设备私有数据
31. struct globalfifo_dev* globalfifo_devp;
34. /* user open fd */
35. static int globalfifo_open(struct inode* inode, struct file* filp) {
36.    
37.     struct globalfifo_dev* dev;
38.     dev = container_of(inode->i_cdev, struct globalfifo_dev, m_cdev);
39.     filp->private_data = dev;
40.     return 0;
41. }
44. /* user release fd*/
45. static int globalfifo_release(struct inode* inode, struct file* filp) {
46.     return 0;
47. }
51. /* user read fd */
52. static ssize_t globalfifo_read(struct file* filp, char __user* buf, size_t count, loff_t* ppos) {
53.     int ret;   
54.     struct globalfifo_dev* dev = filp->private_data;   
55.    
56.     // 定义等待队列
57.     DECLARE_WAITQUEUE(wait, current);   
59.     down(&dev->sem);
61.     // 1.将等待队列加入到等待队列头
62.     add_wait_queue(&dev->r_wait, &wait);
64.     // 2.循环检查等待条件（防止假唤醒，如果唤醒后不满足条件会再次睡眠）
65.     while (dev->current_len == 0) {
66.         // 3. 检查非阻塞模式直接返回
67.         if (filp->f_flags & O_NONBLOCK) {
68.             ret = -EAGAIN;
69.             up(&dev->sem);
70.             remove_wait_queue(&dev->w_wait, &wait);
71.             set_current_state(TASK_RUNNING);
72.             return ret;
73.         }
74.         // 4.改变进程状态为可中断睡眠
75.         __set_current_state(TASK_INTERRUPTIBLE);
77.         up(&dev->sem);
79.         // 5.调度其他进程执行（真正睡眠）        
80.         schedule();
82.         // 6.检查如果有信号到达返回上层处理错误（自己的唤醒只将状态转换为TASK_RUNNING，但信号到来也会做这个处理）
83.         if (signal_pending(current)) {
84.             ret = -ERESTARTSYS;
85.             remove_wait_queue(&dev->w_wait, &wait);
86.             set_current_state(TASK_RUNNING);
87.             return ret;
88.         }
89.         
90.         // 被唤醒后的处理
91.         down(&dev->sem);
92.     }
94.     if(count > dev->current_len)
95.         count = dev->current_len;
97.     if(copy_to_user(buf, dev->mem, count)) {
98.         ret = -EFAULT;
99.         up(&dev->sem);
100.         remove_wait_queue(&dev->w_wait, &wait);
101.            set_current_state(TASK_RUNNING);
102.         return ret;
103.     } else {
104.         memcpy(dev->mem, dev->mem + count, dev->current_len - count);
105.         dev->current_len -= count;
106.             
107.         wake_up_interruptible(&dev->w_wait);    // 读出数据后唤醒写进程
108.         ret = count;
109.     }
110.    
111.     up(&dev->sem);
112.     remove_wait_queue(&dev->w_wait, &wait);
113.     set_current_state(TASK_RUNNING);
115.     return ret;
116. }
119. /* user write fd */
120. static ssize_t globalfifo_write(struct file* filp, const char __user* buf, size_t count, loff_t* ppos) {
121.     int ret;   
122.     struct globalfifo_dev* dev = filp->private_data;   
124.     // 定义等待队列
125.     DECLARE_WAITQUEUE(wait, current);
126.     down(&dev->sem);
127.     // 1.将等待队列插入写等待队列头
128.     add_wait_queue(&dev->w_wait, &wait);
130.     // 2.循环等待 若FIFO满则应该挂起
131.     while (dev->current_len == GLOBALFIFO_SIZE) {
132.         // 3. 若非阻塞则直接返回
133.         if (filp->f_flags & O_NONBLOCK) {
134.             up(&dev->sem);
135.             ret = -EAGAIN;
136.             remove_wait_queue(&dev->w_wait, &wait);
137.             set_current_state(TASK_RUNNING);
138.             return ret;
139.         }
140.         // 4.将进程状态改为可打断睡眠
141.         __set_current_state(TASK_INTERRUPTIBLE);
142.         up(&dev->sem);
143.         // 5.调度其他进程（真正睡眠）
144.         schedule();
146.         // 6.若因为信号唤醒，则返回让上层完成错误处理
147.         if (signal_pending(current)) {
148.             ret = -ERESTARTSYS;
149.             remove_wait_queue(&dev->w_wait, &wait);
150.             set_current_state(TASK_RUNNING);
151.             return ret;
152.         }
153.         down(&dev->sem);
154.     }
156.     if (count > GLOBALFIFO_SIZE - dev->current_len)
157.         count = GLOBALFIFO_SIZE - dev->current_len;
159.     if (copy_from_user(dev->mem, buf, count)) {
160.         ret = -EFAULT;
161.         up(&dev->sem);
162.         remove_wait_queue(&dev->w_wait, &wait);
163.         set_current_state(TASK_RUNNING);
164.         return ret;
165.     } else {
166.         dev->current_len += count;
167.         // 唤醒等待队列
168.         wake_up_interruptible(&dev->r_wait);
169.         ret = count;   
170.     }
172.     up(&dev->sem);
173.     remove_wait_queue(&dev->w_wait, &wait);
174.     set_current_state(TASK_RUNNING);
176.     return count;
177. }
180. /* user lseek fd */
181. static loff_t globalfifo_llseek(struct file* filp, loff_t offset, int orig) {
182.     loff_t ret;
183.     switch(orig) {
184.     // 从起始位置开始移动指针
185.     case 0:
186.         if(offset < 0) {
187.             ret = -EINVAL;
188.             break;
189.         }
190.         if((unsigned int)offset > GLOBALFIFO_SIZE) {
191.             ret = -EINVAL;
192.             break;
193.         }
194.         filp->f_pos = (unsigned int)offset;
195.         ret = filp->f_pos;
196.         break;
197.     // 从当前位置开始移动指针
198.     case 1:
199.         if((filp->f_pos + offset) > GLOBALFIFO_SIZE) {
200.             ret = -EINVAL;
201.             break;
202.         }
203.         if((filp->f_pos + offset) < 0) {
204.             ret = -EINVAL;
205.             break;
206.         }
207.         filp->f_pos += offset;
208.         ret = filp->f_pos;
209.         break;
210.     default:
211.         ret = -EINVAL;
212.     }
213.     return ret;
214. }
217. /* user ioctl fd */
218. static long globalfifo_unlocked_ioctl(struct file *filp, unsigned int cmd, unsigned long arg){
219.     // 获取设备结构体指针   
220.     struct globalfifo_dev* dev = filp->private_data;   
221.    
222.     switch(cmd) {
223.     case MEM_CLEAR:
224.         down(&dev->sem);
225.         dev->current_len = 0;
226.         memset(dev->mem, 0, GLOBALFIFO_SIZE);
227.         up(&dev->sem);
228.         break;
229.     default:
230.         return -EINVAL;
231.     }
232.     return 0;
233. }
237. static const struct file_operations globalfifo_fops = {
238.     .owner = THIS_MODULE,
239.     .open = globalfifo_open,
240.     .release = globalfifo_release,
241.     .llseek = globalfifo_llseek,
242.     .read = globalfifo_read,
243.     .write = globalfifo_write,
244.     .unlocked_ioctl = globalfifo_unlocked_ioctl
245. };
248. /* 设备驱动模块insmod加载函数 */
249. static int globalfifo_init(void) {
250.     // 向 Linux 内核中注册字符设备编号范围
251.     register_chrdev_region(MKDEV(globalfifo_major, 0), 1, "globalfifo");
253.     // 为设备以及共享内存分配内存
254.     globalfifo_devp = kmalloc(sizeof(struct globalfifo_dev), GFP_KERNEL);
255.     memset(globalfifo_devp, 0, sizeof(struct globalfifo_dev));
256.    
257.     // 初始化字符设备0的基本字段
258.     cdev_init(&globalfifo_devp->m_cdev, &globalfifo_fops);
259.     globalfifo_devp->m_cdev.owner = THIS_MODULE;
260.     // 将主设备号globalfifo_major次设备号0，与字符设备驱动的关联
261.     cdev_add(&globalfifo_devp->m_cdev, MKDEV(globalfifo_major, 0), 1);
263.     // 初始化信号量
264.     sema_init(&globalfifo_devp->sem, 1);
266.     // 初始化读写等待队列头
267.     init_waitqueue_head(&globalfifo_devp->r_wait);
268.     init_waitqueue_head(&globalfifo_devp->w_wait);
269.     return 0;
270. }
273. static void globalfifo_exit(void) {
274.     dev_t devno;
275.     // 注销cdev
276.     cdev_del(&globalfifo_devp->m_cdev);
277.     // 释放设备结构体内存
278.     kfree(globalfifo_devp);   
279.     // 释放设备号
280.     devno = MKDEV(globalfifo_major, 0);
281.     unregister_chrdev_region(devno, 1);
282. }
285. MODULE_AUTHOR("cear");
286. MODULE_LICENSE("GPL");
288. module_param(globalfifo_major, int, S_IRUGO);
289. module_init(globalfifo_init);
290. module_exit(globalfifo_exit);

复制代码

 

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

感谢发布原创作品，程序园因你更精彩

yyds。多谢分享

过来提前占个楼

热心回复！

过来提前占个楼

收藏一下   不知道什么时候能用到

喜欢鼓捣这些软件，现在用得少，谢谢分享！