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

linux设备驱动阻塞IO应用 _

news 2026/6/12 17:36:26

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

1.1 wait_queue_head_t

定义等待队列头

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

1.2 init_waitqueue_head

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

void init_waitqueue_head(wait_queue_head_t *q);

1.3 DECLARE_WAITQUEUE

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

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

1.4 add_wait_queue

将一个已经初始化好的等待队列项 wait 添加到等待队列头 queue 所管理的队列中。添加后，该队列项就成为了等待队列的一部分

在进程准备睡眠之前，先将自己添加到等待队列，这样其他唤醒者才能找到它

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

1.5 set_current_state

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

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

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

1.6`remove_wait_queue`

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

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

1.7`wake_up`

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

void wake_up(wait_queue_head_t *queue);

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

void wake_up_interruptible(wait_queue_head_t *queue);

2. 阻塞驱动使用例子

#include <linux/init.h> #include <linux/errno.h> #include <linux/mm.h> #include <linux/sched.h> #include <linux/module.h> #include <linux/ioctl.h> #include <linux/io.h> #include <linux/fs.h> #include <linux/cdev.h> #include <linux/uaccess.h> #include <linux/slab.h> #include <linux/wait.h> #define GLOBALFIFO_SIZE 1024 #define GLOBALMEM_MAGIC 'M' #define MEM_CLEAR _IO(GLOBALMEM_MAGIC, 0) struct globalfifo_dev { struct cdev m_cdev; /* 字符设备 */ unsigned int current_len; /* fifo有效数据长度 */ unsigned char mem[GLOBALFIFO_SIZE]; /* 全局内存 */ struct semaphore sem; /* 并发控制信号量 */ wait_queue_head_t r_wait; /* 阻塞读等待队列头 */ wait_queue_head_t w_wait; /* 阻塞写等待队列头 */ }; static int globalfifo_major = 266; // 存放字符设备私有数据 struct globalfifo_dev* globalfifo_devp; /* user open fd */ static int globalfifo_open(struct inode* inode, struct file* filp) { struct globalfifo_dev* dev; dev = container_of(inode->i_cdev, struct globalfifo_dev, m_cdev); filp->private_data = dev; return 0; } /* user release fd*/ static int globalfifo_release(struct inode* inode, struct file* filp) { return 0; } /* user read fd */ static ssize_t globalfifo_read(struct file* filp, char __user* buf, size_t count, loff_t* ppos) { int ret; struct globalfifo_dev* dev = filp->private_data; // 定义等待队列 DECLARE_WAITQUEUE(wait, current); down(&dev->sem); // 1.将等待队列加入到等待队列头 add_wait_queue(&dev->r_wait, &wait); // 2.循环检查等待条件（防止假唤醒，如果唤醒后不满足条件会再次睡眠） while (dev->current_len == 0) { // 3. 检查非阻塞模式直接返回 if (filp->f_flags & O_NONBLOCK) { ret = -EAGAIN; up(&dev->sem); remove_wait_queue(&dev->w_wait, &wait); set_current_state(TASK_RUNNING); return ret; } // 4.改变进程状态为可中断睡眠 __set_current_state(TASK_INTERRUPTIBLE); up(&dev->sem); // 5.调度其他进程执行（真正睡眠） schedule(); // 6.检查如果有信号到达返回上层处理错误（自己的唤醒只将状态转换为TASK_RUNNING，但信号到来也会做这个处理） if (signal_pending(current)) { ret = -ERESTARTSYS; remove_wait_queue(&dev->w_wait, &wait); set_current_state(TASK_RUNNING); return ret; } // 被唤醒后的处理 down(&dev->sem); } if(count > dev->current_len) count = dev->current_len; if(copy_to_user(buf, dev->mem, count)) { ret = -EFAULT; up(&dev->sem); remove_wait_queue(&dev->w_wait, &wait); set_current_state(TASK_RUNNING); return ret; } else { memcpy(dev->mem, dev->mem + count, dev->current_len - count); dev->current_len -= count; wake_up_interruptible(&dev->w_wait); // 读出数据后唤醒写进程 ret = count; } up(&dev->sem); remove_wait_queue(&dev->w_wait, &wait); set_current_state(TASK_RUNNING); return ret; } /* user write fd */ static ssize_t globalfifo_write(struct file* filp, const char __user* buf, size_t count, loff_t* ppos) { int ret; struct globalfifo_dev* dev = filp->private_data; // 定义等待队列 DECLARE_WAITQUEUE(wait, current); down(&dev->sem); // 1.将等待队列插入写等待队列头 add_wait_queue(&dev->w_wait, &wait); // 2.循环等待 若FIFO满则应该挂起 while (dev->current_len == GLOBALFIFO_SIZE) { // 3. 若非阻塞则直接返回 if (filp->f_flags & O_NONBLOCK) { up(&dev->sem); ret = -EAGAIN; remove_wait_queue(&dev->w_wait, &wait); set_current_state(TASK_RUNNING); return ret; } // 4.将进程状态改为可打断睡眠 __set_current_state(TASK_INTERRUPTIBLE); up(&dev->sem); // 5.调度其他进程（真正睡眠） schedule(); // 6.若因为信号唤醒，则返回让上层完成错误处理 if (signal_pending(current)) { ret = -ERESTARTSYS; remove_wait_queue(&dev->w_wait, &wait); set_current_state(TASK_RUNNING); return ret; } down(&dev->sem); } if (count > GLOBALFIFO_SIZE - dev->current_len) count = GLOBALFIFO_SIZE - dev->current_len; if (copy_from_user(dev->mem, buf, count)) { ret = -EFAULT; up(&dev->sem); remove_wait_queue(&dev->w_wait, &wait); set_current_state(TASK_RUNNING); return ret; } else { dev->current_len += count; // 唤醒等待队列 wake_up_interruptible(&dev->r_wait); ret = count; } up(&dev->sem); remove_wait_queue(&dev->w_wait, &wait); set_current_state(TASK_RUNNING); return count; } /* user lseek fd */ static loff_t globalfifo_llseek(struct file* filp, loff_t offset, int orig) { loff_t ret; switch(orig) { // 从起始位置开始移动指针 case 0: if(offset < 0) { ret = -EINVAL; break; } if((unsigned int)offset > GLOBALFIFO_SIZE) { ret = -EINVAL; break; } filp->f_pos = (unsigned int)offset; ret = filp->f_pos; break; // 从当前位置开始移动指针 case 1: if((filp->f_pos + offset) > GLOBALFIFO_SIZE) { ret = -EINVAL; break; } if((filp->f_pos + offset) < 0) { ret = -EINVAL; break; } filp->f_pos += offset; ret = filp->f_pos; break; default: ret = -EINVAL; } return ret; } /* user ioctl fd */ static long globalfifo_unlocked_ioctl(struct file *filp, unsigned int cmd, unsigned long arg){ // 获取设备结构体指针 struct globalfifo_dev* dev = filp->private_data; switch(cmd) { case MEM_CLEAR: down(&dev->sem); dev->current_len = 0; memset(dev->mem, 0, GLOBALFIFO_SIZE); up(&dev->sem); break; default: return -EINVAL; } return 0; } static const struct file_operations globalfifo_fops = { .owner = THIS_MODULE, .open = globalfifo_open, .release = globalfifo_release, .llseek = globalfifo_llseek, .read = globalfifo_read, .write = globalfifo_write, .unlocked_ioctl = globalfifo_unlocked_ioctl }; /* 设备驱动模块insmod加载函数 */ static int globalfifo_init(void) { // 向 Linux 内核中注册字符设备编号范围 register_chrdev_region(MKDEV(globalfifo_major, 0), 1, "globalfifo"); // 为设备以及共享内存分配内存 globalfifo_devp = kmalloc(sizeof(struct globalfifo_dev), GFP_KERNEL); memset(globalfifo_devp, 0, sizeof(struct globalfifo_dev)); // 初始化字符设备0的基本字段 cdev_init(&globalfifo_devp->m_cdev, &globalfifo_fops); globalfifo_devp->m_cdev.owner = THIS_MODULE; // 将主设备号globalfifo_major次设备号0，与字符设备驱动的关联 cdev_add(&globalfifo_devp->m_cdev, MKDEV(globalfifo_major, 0), 1); // 初始化信号量 sema_init(&globalfifo_devp->sem, 1); // 初始化读写等待队列头 init_waitqueue_head(&globalfifo_devp->r_wait); init_waitqueue_head(&globalfifo_devp->w_wait); return 0; } static void globalfifo_exit(void) { dev_t devno; // 注销cdev cdev_del(&globalfifo_devp->m_cdev); // 释放设备结构体内存 kfree(globalfifo_devp); // 释放设备号 devno = MKDEV(globalfifo_major, 0); unregister_chrdev_region(devno, 1); } MODULE_AUTHOR("cear"); MODULE_LICENSE("GPL"); module_param(globalfifo_major, int, S_IRUGO); module_init(globalfifo_init); module_exit(globalfifo_exit);

查看全文

http://www.jsqmd.com/news/582191/