linux等待队列wait_queue_head_t和wait_queue_t

最新推荐文章于 2024-12-30 08:43:42 发布
转载 最新推荐文章于 2024-12-30 08:43:42 发布 · 393 阅读 · 0

本文深入探讨了Linux内核中等待队列的原理与应用，包括其定义、作用、操作和唤醒机制。详细介绍了等待队列头、等待队列项的数据结构及其字段详解，同时阐述了如何在内核中使用等待队列进行进程同步、阻塞进程的唤醒等功能。

等待队列在linux内核中有着举足轻重的作用，很多linux驱动都或多或少涉及到了等待队列。因此，对于linux内核及驱动开发者来说，掌握等待队列是必须课之一。 Linux内核的等待队列是以双循环链表为基础数据结构，与进程调度机制紧密结合，能够用于实现核心的异步事件通知机制。它有两种数据结构：等待队列头（wait_queue_head_t）和等待队列项（wait_queue_t）。等待队列头和等待队列项中都包含一个list_head类型的域作为”连接件”。它通过一个双链表和把等待task的头，和等待的进程列表链接起来。下面具体介绍。

一、定义：

头文件：/include/linux/wait.h

1 struct __wait_queue_head {
2     spinlock_t lock;
3     struct list_head task_list;
4 };
5 typedef struct __wait_queue_head wait_queue_head_t;

二、作用：

在内核里面，等待队列是有很多用处的，尤其是在中断处理、进程同步、定时等场合。可以使用等待队列在实现阻塞进程的唤醒。它以队列为基础数据结构，与进程调度机制紧密结合，能够用于实现内核中的异步事件通知机制，同步对系统资源的访问等。

三、字段详解：

1、spinlock_t lock;

 在对task_list与操作的过程中，使用该锁实现对等待队列的互斥访问。

 2、srtuct list_head_t task_list;

双向循环链表，存放等待的进程。

三、操作：

1、定义并初始化：

(1)

1 wait_queue_head_t my_queue;
2 init_waitqueue_head(&my_queue);

直接定义并初始化。init_waitqueue_head()函数会将自旋锁初始化为未锁，等待队列初始化为空的双向循环链表。

(2)

DECLARE_WAIT_QUEUE_HEAD(my_queue);

定义并初始化，相当于(1)。

(3) 定义等待队列：

DECLARE_WAITQUEUE(name,tsk);

注意此处是定义一个wait_queue_t类型的变量name，并将其private与设置为tsk。wait_queue_t类型定义如下：

1 typedef struct __wait_queue wait_queue_t;
2  
3 struct __wait_queue {
4     unsigned int flags;
5 #define WQ_FLAG_EXCLUSIVE   0x01
6     void *private;
7     wait_queue_func_t func;
8     struct list_head task_list;
9 };

其中flags域指明该等待的进程是互斥进程还是非互斥进程。其中0是非互斥进程，WQ_FLAG_EXCLUSIVE(0×01)是互斥进程。等待队列(wait_queue_t)和等待对列头(wait_queue_head_t)的区别是等待队列是等待队列头的成员。也就是说等待队列头的task_list域链接的成员就是等待队列类型的(wait_queue_t)。等待队列

2、(从等待队列头中)添加／移出等待队列：

(1) add_wait_queue()函数：

01 void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)
02 {
03     unsigned long flags;
04  
05     wait->flags &= ~WQ_FLAG_EXCLUSIVE;
06     spin_lock_irqsave(&q->lock, flags);
07     __add_wait_queue(q, wait);
08     spin_unlock_irqrestore(&q->lock, flags);
09 }
10 EXPORT_SYMBOL(add_wait_queue);

设置等待的进程为非互斥进程，并将其添加进等待队列头(q)的队头中。

01 void add_wait_queue_exclusive(wait_queue_head_t *q, wait_queue_t *wait)
02 {
03     unsigned long flags;
04  
05     wait->flags |= WQ_FLAG_EXCLUSIVE;
06     spin_lock_irqsave(&q->lock, flags);
07     __add_wait_queue_tail(q, wait);
08     spin_unlock_irqrestore(&q->lock, flags);
09 }
10 EXPORT_SYMBOL(add_wait_queue_exclusive);

该函数也和add_wait_queue()函数功能基本一样，只不过它是将等待的进程(wait)设置为互斥进程。

(2)remove_wait_queue()函数：

1 void remove_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)
2 {
3     unsigned long flags;
4  
5     spin_lock_irqsave(&q->lock, flags);
6     __remove_wait_queue(q, wait);
7     spin_unlock_irqrestore(&q->lock, flags);
8 }
9 EXPORT_SYMBOL(remove_wait_queue);

在等待的资源或事件满足时，进程被唤醒，使用该函数被从等待头中删除。

3、等待事件：

(1)wait_event()宏：

01 /**
02  * wait_event - sleep until a condition gets true
03  * @wq: the waitqueue to wait on
04  * @condition: a C expression for the event to wait for
05  *
06  * The process is put to sleep (TASK_UNINTERRUPTIBLE) until the
07  * @condition evaluates to true. The @condition is checked each time
08  * the waitqueue @wq is woken up.
09  *
10  * wake_up() has to be called after changing any variable that could
11  * change the result of the wait condition.
12  */
13 #define wait_event(wq, condition)                   \
14 do {                                    \
15     if (condition)                          \
16         break;                          \
17     __wait_event(wq, condition);                    \
18 } while (0)

在等待会列中睡眠直到condition为真。在等待的期间，进程会被置为TASK_UNINTERRUPTIBLE进入睡眠，直到condition变量变为真。每次进程被唤醒的时候都会检查condition的值.

(2)wait_event_interruptible()函数:

和wait_event()的区别是调用该宏在等待的过程中当前进程会被设置为TASK_INTERRUPTIBLE状态.在每次被唤醒的时候,首先检查condition是否为真,如果为真则返回,否则检查如果进程是被信号唤醒,会返回-ERESTARTSYS错误码.如果是condition为真,则返回0.

(3)wait_event_timeout()宏:

也与wait_event()类似.不过如果所给的睡眠时间为负数则立即返回.如果在睡眠期间被唤醒,且condition为真则返回剩余的睡眠时间,否则继续睡眠直到到达或超过给定的睡眠时间,然后返回0.

(4)wait_event_interruptible_timeout()宏:

 与wait_event_timeout()类似,不过如果在睡眠期间被信号打断则返回ERESTARTSYS错误码.

(5) wait_event_interruptible_exclusive()宏

同样和wait_event_interruptible()一样,不过该睡眠的进程是一个互斥进程.

5、唤醒队列:

(1)wake_up()函数:

01 #define wake_up(x)          __wake_up(x, TASK_NORMAL, 1, NULL)
02  
03 /**
04  * __wake_up - wake up threads blocked on a waitqueue.
05  * @q: the waitqueue
06  * @mode: which threads
07  * @nr_exclusive: how many wake-one or wake-many threads to wake up
08  * @key: is directly passed to the wakeup function
09  */
10 void __wake_up(wait_queue_head_t *q, unsigned int mode,
11             int nr_exclusive, void *key)
12 {
13     unsigned long flags;
14  
15     spin_lock_irqsave(&q->lock, flags);
16     __wake_up_common(q, mode, nr_exclusive, 0, key);
17     spin_unlock_irqrestore(&q->lock, flags);
18 }
19 EXPORT_SYMBOL(__wake_up);

唤醒等待队列.可唤醒处于TASK_INTERRUPTIBLE和TASK_UNINTERUPTIBLE状态的进程,和wait_event/wait_event_timeout成对使用.

(2)wake_up_interruptible()函数:

1 #define wake_up_interruptible(x)    __wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)

和wake_up()唯一的区别是它只能唤醒TASK_INTERRUPTIBLE状态的进程.,与wait_event_interruptible/wait_event_interruptible_timeout/ wait_event_interruptible_exclusive成对使用. (3)

1 #define wake_up_all(x)          __wake_up(x, TASK_NORMAL, 0, NULL)
2  
3 #define wake_up_interruptible_nr(x, nr) __wake_up(x, TASK_INTERRUPTIBLE, nr, NULL)
4 #define wake_up_interruptible_all(x)    __wake_up(x, TASK_INTERRUPTIBLE, 0, NULL)

这些也基本都和wake_up/wake_up_interruptible一样.

6、在等待队列上睡眠：

(1) sleep_on()函数:

01 void __sched sleep_on(wait_queue_head_t *q)
02 {
03     sleep_on_common(q, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
04 }
05  
06 static long __sched
07 sleep_on_common(wait_queue_head_t *q, int state, long timeout)
08 {
09     unsigned long flags;
10     wait_queue_t wait;
11  
12     init_waitqueue_entry(&wait, current);
13  
14     __set_current_state(state);
15  
16     spin_lock_irqsave(&q->lock, flags);
17     __add_wait_queue(q, &wait);
18     spin_unlock(&q->lock);
19     timeout = schedule_timeout(timeout);
20     spin_lock_irq(&q->lock);
21     __remove_wait_queue(q, &wait);
22     spin_unlock_irqrestore(&q->lock, flags);
23  
24     return timeout;
25 }

该函数的作用是定义一个等待队列(wait)，并将当前进程添加到等待队列中(wait)，然后将当前进程的状态置为TASK_UNINTERRUPTIBLE，并将等待队列(wait)添加到等待队列头(q)中。之后就被挂起直到资源可以获取，才被从等待队列头(q)中唤醒，从等待队列头中移出。在被挂起等待资源期间，该进程不能被信号唤醒。

(2)sleep_on_timeout()函数：

1 long __sched sleep_on_timeout(wait_queue_head_t *q, long timeout)
2 {
3     return sleep_on_common(q, TASK_UNINTERRUPTIBLE, timeout);
4 }
5 EXPORT_SYMBOL(sleep_on_timeout);

与sleep_on()函数的区别在于调用该函数时，如果在指定的时间内(timeout)没有获得等待的资源就会返回。实际上是调用schedule_timeout()函数实现的。值得注意的是如果所给的睡眠时间(timeout)小于0，则不会睡眠。该函数返回的是真正的睡眠时间。

(3)interruptible_sleep_on()函数：

1 void __sched interruptible_sleep_on(wait_queue_head_t *q)
2 {
3     sleep_on_common(q, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
4 }
5 EXPORT_SYMBOL(interruptible_sleep_on);

该函数和sleep_on()函数唯一的区别是将当前进程的状态置为TASK_INTERRUPTINLE，这意味在睡眠如果该进程收到信号则会被唤醒。

(4)interruptible_sleep_on_timeout()函数：

1 long __sched
2 interruptible_sleep_on_timeout(wait_queue_head_t *q, long timeout)
3 {
4     return sleep_on_common(q, TASK_INTERRUPTIBLE, timeout);
5 }
6 EXPORT_SYMBOL(interruptible_sleep_on_timeout);

类似于sleep_on_timeout()函数。进程在睡眠中可能在等待的时间没有到达就被信号打断而被唤醒，也可能是等待的时间到达而被唤醒。

以上四个函数都是让进程在等待队列上睡眠，不过是小有诧异而已。在实际用的过程中，根据需要选择合适的函数使用就是了。例如在对软驱数据的读写中，如果设备没有就绪则调用sleep_on()函数睡眠直到数据可读(可写)，在打开串口的时候，如果串口端口处于关闭状态则调用interruptible_sleep_on()函数尝试等待其打开。在声卡驱动中，读取声音数据时，如果没有数据可读，就会等待足够常的时间直到可读取。


Linux 内核等待队列（wait queue）机制详解
deeplyMind
09-01 1212
本文介绍了Linux内核中的等待队列机制，该机制通过wait_queue_head和wait_queue_entry数据结构实现进程/线程的睡眠与唤醒。等待队列广泛应用于驱动、内存管理等领域，支持普通、独占和优先级等唤醒策略。文章详细讲解了等待队列的声明初始化、使用流程（睡眠/唤醒）、高级用法（条件等待宏）及内核实现原理，包括链表结构、并发保护等。最后总结了典型应用场景和使用建议，强调合理选择唤醒方式、防范死锁竞态等问题。等待队列是Linux内核实现高效并发同步的核心机制之一。
linux等待队列wait queue
夏天Alex
03-29 5339
linux内核的等待队列是在内核中运用非常广泛的数据结构，它是以双循环链表为基础的数据结构，与进程的休眠---唤醒机制紧密相连，可以用来同步对系统资源的访问、异步事件通知、跨进程通信等。 假设进程A想要获取某资源（读网卡数据），但是此时资源没有准备好（网卡还未接收到数据），这时内核必须切换到其他进程进行，直到资源准备好再唤醒该进程。 1、等待队列头 struct __wait_queue_head { spinlock_t lock; //...
Linux内核--wait_queue_head机制流程简介
qq_30239761的博客
02-02 750
core.c int default_wake_function(wait_queue_entry_t *curr, unsigned mode, int wake_flags, void *key) { return try_to_wake_up(curr->private, mode, wake_flags, 1); // wake up a thread } EXPORT_SYMBOL(default_wake_function); wait.h /* A single wait-queue
linux-等待队列（Wait Queue）
weixin_43412488的博客
12-13 2041
Wait Queue
Linux内核之——等待队列wait queue
weixin_44537992的博客
05-21 4959
前言 等待队列1 等待队列2 调度器 CPU调度如下图所示： 等待队列其原理是： cpu会调度就绪队列，或者打断执行线程，运行就绪队列 创建等待队列头和队列，使用wait event，当condition不满足时，当前线程进入等待队列 通过将当前线程加入等待队列中，同时schedule调度走cpu执行别的线程，下次cpu便不会再调度当前线程了 当wakeup后，将wait线程加入run que...
Linux内核的等待队列（转载）
liaoxinmeng的专栏
12-12 1818
 Linux内核的等待队列是以双循环链表为基础数据结构，与进程调度机制紧密结合，能够用于实现核心的异步事件通知机制。在Linux2.4.21中，等待队列在源代码树include/linux/wait.h中，这是一个通过list_head连接的典型双循环链表，如下图所示。 screen.width*0.7) {this.resized=true; this.width=screen.widt
linux内核等待队列wait_queue_head_t
10-19 2088
linux内核等待队列wait_queue_head_t
理解并使用Linux内核等待队列wait_queue
Linux内核研究者
12-30 1994
等待队列是Linux内核中非常重要的同步机制，广泛应用于驱动开发和多线程编程。通过本教程，我们掌握了基本的使用方法、底层实现原理，以及高级用法。深入学习等待队列，有助于更好地理解Linux内核的线程调度与同步机制。
介绍一下等待队列的数据结构详情，wait_queue_head_t 以及其节点 __wait_head
最新发布
04-28
此外，需要涵盖等待队列的使用流程，如初始化、添加/移除等待项、进入等待状态、唤醒等步骤，并结合实际的内核函数或宏，如`DECLARE_WAIT_QUEUE_HEAD`、`init_waitqueue_head`、`add_wait_queue`、`wait_event`、`...
Linux 内核等待队列 --- wait_queue_head --- wait_event_interruptible
10-10 1604
转自https://blog.youkuaiyun.com/yikai2009/article/details/8653578   等待队列：           在 Linux 驱动程序设计中，可以使用等待队列来实现进程的阻塞.           等待队列可以看作保存进程的容器，在阻塞进程时，将进程放入等待队列；           当唤醒进程时，从等待队列中取出进程.   等待队列的 定义...
Linux内核之等待队列wait_queue_head_t数据结构用法实例(四十)
Android系统攻城狮
04-10 2150
本篇目的：Linux内核之等待队列wait_queue_head_t用法实例是 Linux 内核中用于实现等待队列的基本数据结构。在 Linux 内核中，等待队列是一种常见的机制，用于让进程在某个条件不满足时进入睡眠状态，当条件满足时被唤醒继续执行。这种机制在很多内核子系统中都有应用，如进程调度、设备驱动、同步等。结构体定义了一个等待队列的头部，它包含了等待队列的基本信息和一个用于同步的锁。等待队列实际上是一个进程列表，这些进程都在等待某个条件变为真。每个等待队列都有一个对应的结构体，用于管理这个队列。
Linux驱动之等待队列
qq_53221728的博客
04-17 1489
Linux驱动之等待队列。定时器按键消抖、
wait_queue_head_t & wait_queue_t(MTD)
Woodpecker Blog
12-11 1521
wait_queue_head_t & wait_queue_t使用(MTD)
Linux等待队列wait_queue_head_t和wait_queue_t
miaomao1989
08-18 1094
Linux等待队列wait_queue_head_t和wait_queue_t
wait_queue_head_t和wait_queue_t
ask_true的博客
11-04 182
linux等待队列wait_queue_head_t和wait_queue_t_bytxl的专栏-优快云博客 DECLARE_WAITQUEUE(wait, current); #define DECLARE_WAITQUEUE(name, tsk) \ struct wait_queue_entry name = __WAITQUEUE_INITIALIZER(name, tsk) #define __WAITQUEUE_INITIALIZER(name, tsk) { \
Linux内核等待队列探究-wait_queue_t-wait_queue_head_t
YACHL882828的博客
11-01 2694
Linux内核等待队列探究-wait_queue_t-wait_queue_head_t 【 相关源码版本： LINUX内核源码版本：linux-3.0.86 UBOOT版本：uboot-2010.12. Android系统源码版本：Android-5.0.2】   等待队列是LINUX内核实现阻塞访问的方式之一，同时LINUX内核的信号量和完成量都是用等待队列来实现的低层方
介绍一下等待队列的数据结构详情，wait_queue_head_t
04-28
<think>嗯，用户现在想了解Linux内核中的等待队列数据结构，特别是wait_queue_head_t的定义和用法。他们之前已经讨论过struct lock_class_key，所以可能需要结合锁机制来理解等待队列的实现。 首先，我需要回顾用户提供的引用内容。引用[3]和[4]详细说明了wait_queue_head_t的结构和创建方法。结构体包含spinlock_t和list_head，用于保护队列和连接等待项。用户提到的DECLARE_WAIT_QUEUE_HEAD和init_waitqueue_head两种创建方式，其中动态创建使用了lock_class_key，这和之前讨论的锁调试机制有关联，可能需要解释这部分如何避免锁冲突。 用户可能想知道wait_queue_head_t在内核中的具体作用，比如如何管理等待的进程，以及如何与进程调度结合。需要提到等待队列头作为管理核心，负责同步和唤醒机制。同时，要说明spinlock的作用，保护任务列表的并发访问，确保操作原子性。 还要考虑用户可能的应用场景，比如设备驱动中的阻塞IO操作，使用等待队列来处理资源等待。需要举例说明添加等待队列项和唤醒的过程，展示数据结构如何在实际中使用。 另外，用户之前的提问涉及lock_class_key，所以在动态初始化wait_queue_head_t时，提到的lockdep_set_class_and_name函数可能与锁依赖检测有关，需要解释其重要性，避免假阳性死锁检测。 可能还需要比较静态和动态初始化的区别，说明何时使用哪种方法。例如，静态初始化用于编译时已知的情况，而动态初始化适用于模块加载时的情况，比如可加载内核模块。 最后，确保回答结构清晰，分点说明定义、结构成员、初始化方法、核心作用，以及使用示例。相关问题部分要引导用户深入理解等待队列的实现细节和锁机制的结合，比如spinlock的作用，或者与lockdep的关联。</think>### 深入解析 Linux 内核等待队列的 $wait\_queue\_head\_t$ 数据结构 --- #### 一、数据结构定义与成员解析 **$wait\_queue\_head\_t$ 是等待队列的核心管理结构**，定义在头文件 `/include/linux/wait.h` 中，其结构如下[^3][^4]： ```c struct __wait_queue_head { spinlock_t lock; // 自旋锁，保护任务链表的并发访问 struct list_head task_list; // 双向链表头，连接所有等待项（wait_queue_entry） }; typedef struct __wait_queue_head wait_queue_head_t; ``` ##### 关键成员作用： 1. **$spinlock\_t\ lock$** - 用于在并发场景下保护 $task\_list$ 的原子操作，防止多线程/中断上下文中的竞争条件。 - 锁的类型为自旋锁，适用于短临界区（例如添加/移除等待项操作）[^4]。 2. **$struct\ list\_head\ task\_list$** - 双向链表头，通过 Linux 内核的通用链表机制（`list.h`）挂载所有等待队列项（$wait\_queue\_entry$）。 - 每个等待项代表一个正在等待某个条件成立的进程或线程[^1]。 --- #### 二、初始化方法与锁调试机制 ##### 1. **静态初始化** 通过宏 $DECLARE\_WAIT\_QUEUE\_HEAD$ 在编译期静态分配并初始化： ```c #define DECLARE_WAIT_QUEUE_HEAD(name) \ struct wait_queue_head name = __WAIT_QUEUE_HEAD_INITIALIZER(name) ``` 其中，$__WAIT\_QUEUE\_HEAD\_INITIALIZER$ 展开后初始化自旋锁和链表头： ```c #define __WAIT_QUEUE_HEAD_INITIALIZER(name) { \ .lock = __SPIN_LOCK_UNLOCKED(name.lock), \ // 初始化未加锁状态 .task_list = { &(name).task_list, &(name).task_list } // 空链表初始化 } ``` **适用场景**：全局或静态定义的等待队列头。 ##### 2. **动态初始化** 通过函数 $init\_waitqueue\_head$ 动态初始化已分配的结构： ```c void __init_wait_queue_head(wait_queue_head_t *q, const char *name, struct lock_class_key *key); #define init_waitqueue_head(wq_head) \ do { \ static struct lock_class_key __key; \ // 静态分配 lock_class_key __init_wait_queue_head(wq_head, #wq_head, &__key); \ } while (0) ``` **关键细节**： - **锁调试集成**：通过 $lockdep\_set\_class\_and\_name$ 为自旋锁关联唯一的锁类（基于 $lock\_class\_key$），避免锁依赖检测（lockdep）的假阳性冲突[^4][^1]。 - **动态分配场景**：常用于内核模块中动态分配的等待队列头（如设备驱动初始化时）。 --- #### 三、核心作用与同步机制 ##### 1. **管理等待项的生命周期** - 当进程需要等待某个条件（如 I/O 完成）时，通过 $add\_wait\_queue\_entry()$ 将自身挂载到 $task\_list$ 链表。 - 条件满足时，通过 $wake\_up()$ 系列函数遍历链表并唤醒等待的进程。 ##### 2. **与进程调度的协作** - 等待队列与进程调度深度集成。例如，$wait\_event()$ 宏会将进程状态设为 $TASK\_UNINTERRUPTIBLE$，并主动让出 CPU[^2]。 ##### 3. **典型使用示例（设备驱动）** ```c // 初始化等待队列头 DECLARE_WAIT_QUEUE_HEAD(my_waitq); // 等待条件成立 wait_event(my_waitq, condition); // 唤醒等待队列（通常在中断处理中调用） wake_up(&my_waitq); ``` --- #### 四、与锁调试机制（lockdep）的关联 在动态初始化时，$init\_waitqueue\_head$ 通过 $lock\_class\_key$ 为每个等待队列头的自旋锁分配唯一的锁类[^4]： ```c lockdep_set_class_and_name(&wq_head->lock, key, name); ``` - **作用**：区分不同等待队列的锁实例，避免锁依赖检测误判多个队列的锁为同一类。 - **意义**：例如，多个设备驱动使用同名等待队列时，lockdep 仍能正确追踪锁的获取顺序[^1]。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值