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.6remove_wait_queue将之前通过 add_wait_queue 添加的等待队列项从等待队列中移除当进程被唤醒并重新获得 CPU 后通常需要调用此函数将自己从等待队列中删除表示不再等待该条件如果忘记移除队列项仍留在等待队列中可能导致后续不必要的唤醒或资源泄漏void remove_wait_queue(wait_queue_head_t *queue, wait_queue_t *wait);1.7wake_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);