linux等待队列

最新推荐文章于 2023-12-13 10:51:42 发布
最新推荐文章于 2023-12-13 10:51:42 发布
阅读量3.3k 收藏 5
点赞数
分类专栏： linux内核相关
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/orz415678659/article/details/8316803
版权

一.头文件

#include <linux/wait.h>

二.结构体

1.等待队列头

struct __wait_queue_head {
	spinlock_t lock;
	struct list_head task_list;
};
typedef struct __wait_queue_head wait_queue_head_t;

2.等待队列

struct __wait_queue {
	unsigned int flags;
	void *private;
	wait_queue_func_t func;
	struct list_head task_list;
};
typedef struct __wait_queue wait_queue_t;


三.初始化

1.等待队列头

定义声明等待队列头

#define DECLARE_WAIT_QUEUE_HEAD(name) \
	wait_queue_head_t name = __WAIT_QUEUE_HEAD_INITIALIZER(name)

定义了一个等待队列头,并初始化其成员

#define __WAIT_QUEUE_HEAD_INITIALIZER(name) {			\
	.lock	= __SPIN_LOCK_UNLOCKED(name.lock),		\
	.task_list	= { &(name).task_list, &(name).task_list } }

2.等待队列

定义声明等待队列

#define DECLARE_WAITQUEUE(name, tsk)				\
	wait_queue_t name = __WAITQUEUE_INITIALIZER(name, tsk)

初始化其成员

#define __WAITQUEUE_INITIALIZER(name, tsk) {			\
	.private	= tsk,					\
	.func	= default_wake_function,			\
	.task_list	= { NULL, NULL } }

四.添加与移除等待队列

1.添加等待队列

void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)
{
	unsigned long flags;

	wait->flags &= ~WQ_FLAG_EXCLUSIVE;
	spin_lock_irqsave(&q->lock, flags);
	__add_wait_queue(q, wait);
	spin_unlock_irqrestore(&q->lock, flags);
}

__add_wait_queue本质上就是添加等待队列的task_list进等待队列头的task_list为首项的list链表

static inline void __add_wait_queue_tail(wait_queue_head_t *head, wait_queue_t *new)
{
	list_add_tail(&new->task_list, &head->task_list);
}

2.移除等待队列

void remove_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)
{
	unsigned long flags;

	spin_lock_irqsave(&q->lock, flags);
	__remove_wait_queue(q, wait);
	spin_unlock_irqrestore(&q->lock, flags);
}

__remove_wait_queue本质上就是从等待队列头的task_list为首项的list链表中移除等待队列的task_list

static inline void __remove_wait_queue(wait_queue_head_t *head,wait_queue_t *old)
{
	list_del(&old->task_list);
}

五.等待,唤醒,睡眠
1.等待

1.1 wait_event 等待事件发生,不可中断

#define wait_event(wq, condition) 					\
do {								\
	if (condition)	 					\	//唤醒的条件为真,则退出
		break;						\
	__wait_event(wq, condition);				\
} while (0)

__wait_event

#define __wait_event(wq, condition) 					\
do {								\
	DEFINE_WAIT(__wait);					\
								\
	for (;;) {						\
		prepare_to_wait(&wq, &__wait, TASK_UNINTERRUPTIBLE);	\	//TASK_UNINTERRUPTIBLE标明不可中断
		if (condition)					\	//唤醒的条件为真,则退出for循环
			break;					\
		schedule();					\	//进入调度
	}							\
	finish_wait(&wq, &__wait);					\	//设置进程为TASK_RUNNING,并移除等待队列中的队列项
} while (0)

1.2 wait_event_interruptible 等待事件发生,可中断

#define wait_event_interruptible(wq, condition)			\
({								\
	int __ret = 0;						\
	if (!(condition))						\	//条件为真则退出
		__wait_event_interruptible(wq, condition, __ret);	\	
	__ret;							\
})

__wait_event_interruptible

#define __wait_event_interruptible(wq, condition, ret)			\
do {								\
	DEFINE_WAIT(__wait);					\
								\
	for (;;) {						\
		prepare_to_wait(&wq, &__wait, TASK_INTERRUPTIBLE);	\	//TASK_INTERRUPTIBLE标明可中断
		if (condition)					\	//唤醒的条件为真,则退出for循环
			break;					\
		if (!signal_pending(current)) {			\	//检测当前进程是否有信号要处理
			schedule();				\	//进入调度
			continue;					\
		}						\
		ret = -ERESTARTSYS;				\
		break;						\
	}							\
	finish_wait(&wq, &__wait);					\	//设置进程为TASK_RUNNING,并移除等待队列中的队列项
} while (0)

1.3 wait_event_timeout 超时等待事件，不可中断

#define wait_event_timeout(wq, condition, timeout)			\
({								\
	long __ret = timeout;					\
	if (!(condition)) 						\	//等待条件为真则退出
		__wait_event_timeout(wq, condition, __ret);		\	
	__ret;							\
})

__wait_event_timeout

#define __wait_event_timeout(wq, condition, ret)			\
do {								\
	DEFINE_WAIT(__wait);					\
								\
	for (;;) {						\
		prepare_to_wait(&wq, &__wait, TASK_UNINTERRUPTIBLE);	\	//TASK_UNINTERRUPTIBLE标明不可中断
		if (condition)					\	//唤醒的条件为真,则退出for循环
			break;					\
		ret = schedule_timeout(ret);			\	//调度,并设置超时值
		if (!ret)						\	//超时则退出
			break;					\
	}							\
	finish_wait(&wq, &__wait);					\	//设置进程为TASK_RUNNING,并移除等待队列中的队列项	
} while (0)

1.4 wait_event_interruptible_timeout 超时等待事件,可中断

#define wait_event_interruptible_timeout(wq, condition, timeout)	\
({								\
	long __ret = timeout;					\
	if (!(condition))						\	//等待条件为真则退出
		__wait_event_interruptible_timeout(wq, condition, __ret); \	
	__ret;							\
})

__wait_event_interruptible_timeout

#define __wait_event_interruptible_timeout(wq, condition, ret)		\
do {								\
	DEFINE_WAIT(__wait);					\
								\
	for (;;) {						\
		prepare_to_wait(&wq, &__wait, TASK_INTERRUPTIBLE);	\	//TASK_INTERRUPTIBLE标明可中断
		if (condition)					\	//唤醒的条件为真,则退出for循环
			break;					\
		if (!signal_pending(current)) {			\	//检测当前进程是否有信号要处理
			ret = schedule_timeout(ret);		\	//调度,并设置超时值
			if (!ret)					\	//超时则退出
				break;				\
			continue;					\	
		}						\
		ret = -ERESTARTSYS;				\
		break;						\
	}							\
	finish_wait(&wq, &__wait);					\	//设置进程为TASK_RUNNING,并移除等待队列中的队列项
} while (0)


2.唤醒
2.1 wake_up唤醒不可中断的等待队列

#define wake_up(x)   __wake_up(x, TASK_NORMAL, 1, NULL)

衍生的其他宏

#define wake_up_nr(x, nr)		__wake_up(x, TASK_NORMAL, nr, NULL)
#define wake_up_all(x)			__wake_up(x, TASK_NORMAL, 0, NULL)
#define wake_up_locked(x)		__wake_up_locked((x), TASK_NORMAL)

2.2 wake_up_interruptible唤醒可中断的等待队列

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

衍生的其他宏

#define wake_up_interruptible_nr(x, nr)	__wake_up(x, TASK_INTERRUPTIBLE, nr, NULL)
#define wake_up_interruptible_all(x)	__wake_up(x, TASK_INTERRUPTIBLE, 0, NULL)
#define wake_up_interruptible_sync(x)	__wake_up_sync((x), TASK_INTERRUPTIBLE, 1)

 

两个宏最终都调用__wake_up

void __wake_up(wait_queue_head_t *q, unsigned int mode,int nr_exclusive, void *key)
{
	unsigned long flags;

	spin_lock_irqsave(&q->lock, flags);
	__wake_up_common(q, mode, nr_exclusive, 0, key);	//-->__wake_up_common
	spin_unlock_irqrestore(&q->lock, flags);
}

__wake_up_common

static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,int nr_exclusive, int wake_flags, void *key)
{
	wait_queue_t *curr, *next;

	list_for_each_entry_safe(curr, next, &q->task_list, task_list) {	//遍历等待队列表
		unsigned flags = curr->flags;	
		//调用其等待队列项的func方法,-->default_wake_function
		if (curr->func(curr, mode, wake_flags, key) &&(flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
			break;
	}
}

default_wake_function

int default_wake_function(wait_queue_t *curr, unsigned mode, int wake_flags,void *key)
{
	return try_to_wake_up(curr->private, mode, wake_flags);	//-->try_to_wake_up
	}

try_to_wake_up

static int try_to_wake_up(struct task_struct *p, unsigned int state,int wake_flags)
{
	int cpu, orig_cpu, this_cpu, success = 0;
	unsigned long flags;
	unsigned long en_flags = ENQUEUE_WAKEUP;
	struct rq *rq;
	this_cpu = get_cpu();

	smp_wmb();
	rq = task_rq_lock(p, &flags);
	if (!(p->state & state))
		goto out;

	if (p->se.on_rq)
		goto out_running;

	cpu = task_cpu(p);
	orig_cpu = cpu;

#ifdef CONFIG_SMP
	if (unlikely(task_running(rq, p)))
		goto out_activate;

	if (task_contributes_to_load(p)) {
		if (likely(cpu_online(orig_cpu)))
			rq->nr_uninterruptible--;
		else
			this_rq()->nr_uninterruptible--;
	}
	p->state = TASK_WAKING;

	if (p->sched_class->task_waking) {
		p->sched_class->task_waking(rq, p);
		en_flags |= ENQUEUE_WAKING;
	}

	cpu = select_task_rq(rq, p, SD_BALANCE_WAKE, wake_flags);
	if (cpu != orig_cpu)
		set_task_cpu(p, cpu);
	__task_rq_unlock(rq);

	rq = cpu_rq(cpu);
	raw_spin_lock(&rq->lock);

	WARN_ON(task_cpu(p) != cpu);
	WARN_ON(p->state != TASK_WAKING);

#ifdef CONFIG_SCHEDSTATS
	schedstat_inc(rq, ttwu_count);
	if (cpu == this_cpu)
		schedstat_inc(rq, ttwu_local);
	else {
		struct sched_domain *sd;
		for_each_domain(this_cpu, sd) {
			if (cpumask_test_cpu(cpu, sched_domain_span(sd))) {
				schedstat_inc(sd, ttwu_wake_remote);
				break;
			}
		}
	}
#endif /* CONFIG_SCHEDSTATS */

out_activate:
#endif /* CONFIG_SMP */
	ttwu_activate(p, rq, wake_flags & WF_SYNC, orig_cpu != cpu, cpu == this_cpu, en_flags);	//最终调用activate_task激活等待进程
	success = 1;
out_running:
	ttwu_post_activation(p, rq, wake_flags, success);
out:
	task_rq_unlock(rq, &flags);
	put_cpu();

	return success;
}

3.睡眠

3.1 sleep_on 睡眠,不可中断

void __sched sleep_on(wait_queue_head_t *q)
{
	sleep_on_common(q, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
}

3.2 interruptible_sleep_on 睡眠,可中断

void __sched interruptible_sleep_on(wait_queue_head_t *q)
{
	sleep_on_common(q, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
}

3.3 sleep_on_timeout 超时睡眠,不可中断

long __sched sleep_on_timeout(wait_queue_head_t *q, long timeout)
{
	return sleep_on_common(q, TASK_UNINTERRUPTIBLE, timeout);
}

3.4 interruptible_sleep_on_timeout 超时睡眠,可中断

long __sched interruptible_sleep_on_timeout(wait_queue_head_t *q, long timeout)
{
	return sleep_on_common(q, TASK_INTERRUPTIBLE, timeout);
}

睡眠api最终都会调用sleep_on_common

static long __sched
sleep_on_common(wait_queue_head_t *q, int state, long timeout)
{
	unsigned long flags;
	wait_queue_t wait;

	init_waitqueue_entry(&wait, current);	//初始化等待队列项

	__set_current_state(state);		//设置当前进程的状态TASK_UNINTERRUPTIBLE、TASK_INTERRUPTIBLE

	spin_lock_irqsave(&q->lock, flags);
	__add_wait_queue(q, &wait);	//添加等待队列项
	spin_unlock(&q->lock);
	timeout = schedule_timeout(timeout);	//调度,设置超时值
	spin_lock_irq(&q->lock);
	__remove_wait_queue(q, &wait);	//移除等待队列项
	spin_unlock_irqrestore(&q->lock, flags);

	return timeout;
}


六.整理

//等待队列头
wait_queue_head_t	
//初始化等待队列头
DECLARE_WAIT_QUEUE_HEAD(name)

//等待队列项
wait_queue_t	
//初始化等待队列项
DECLARE_WAITQUEUE(name, tsk)	
//添加移除等待队列项
void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)		//添加等待队列项
void remove_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)	//移除等待队列项
//等待事件
wait_event(wq, condition) 						//等待事件,不可中断	
wait_event_interruptible(wq, condition)				//等待事件,可中断		 
wait_event_timeout(wq, condition, timeout)				//超时等待,不可中断
wait_event_interruptible_timeout(wq, condition, timeout)		//超时等待,可中断	
//唤醒事件
wake_up(x)							//唤醒事件,不可中断
wake_up_interruptible(x)						//唤醒事件,可中断
//等待队列上睡眠
void __sched sleep_on(wait_queue_head_t *q)				//睡眠,不可中断
void __sched interruptible_sleep_on(wait_queue_head_t *q)		//睡眠,可中断
long __sched sleep_on_timeout(wait_queue_head_t *q, long timeout) 	//超时睡眠,不可中断
long __sched interruptible_sleep_on_timeout(wait_queue_head_t *q, long timeout) //超时睡眠,可中断

等待和睡眠本质上在于有无条件,睡眠属于旧版本内核的东西,很少使用到











 


 

paomadi
关注
专栏目录
Linux等待队列和运行队列
zhang_shuaifeng的博客
03-10 509
运行队列、等待队列
源码解读Linux等待队列
weixin_43901866的博客
01-31 401
从源码角度来解读Linux等待队列机制，了解休眠与唤醒的运转原理 kernel/include/linux/wait.h kernel/kernel/sched/wait.c kernel/include/linux/sched.h kernel/kernel/sched/core.c 一、概述 Linux内核的等待队列是非常重要的数据结构，在内核驱动中广为使用，它是以双循环链表为基础数...
Linux等待队列
SegmentFault
09-06 660
多路IO复用select采用等待队列机制让用户程序没有资源读/写时睡眠，有资源读/写时唤醒用户程序。 等待队列以双向循环链表为基础数据结构，与进程调度紧密结合，用于实现内核的异步事件通知机制，也可用于同步对系统资源的访问。 1. 数据结构 (1) 每个等待队列都有一个等待队列头，该结构定义如下： struct __wait_queue_head { spinlock_t lock;
linux内核中等待队列 （函数wait_event与wake_up）
weixin_30361641的博客
01-05 731
根据内核3.1.6版本源码、书籍和网上资料，对几个函数进行分析 介绍这几个函数，不得不先介绍等待队列wait_queue_head_t与完成量completion。 等待队列用于使得进程等待某一特定事件的发生，无需频繁的轮询，进程在等待周期中睡眠，当时间发生后由内核自动唤醒。 完成量机制是基于等待队列的，内核利用该机制等待某一...
等待队列学习笔记
嵌入精灵
08-10 826
<br />一、定义：<br />/include/linux/wait.h<br /> <br />struct __wait_queue_head { <br />spinlock_t lock; <br />struct list_head task_list; <br />}; <br />typedef struct __wait_queue_head wait_queue_head_t;<br />二、作用：<br />在内核里面，等待队列是有很多用处的，尤其是在中断处理、进程同步、定时等场合。
linux 之 等待队列
Whisper_J的专栏
09-21 513
1、等待队列由等待队列头和队列节点构成，当进程要获得某一资源而暂时不能得到时候，进程可以进入睡眠状态 内核为此要生成一个队列节点，并将睡眠的进程挂到等待队列中。 2、等待队列头wait_queue_head_t struct __wait_queue_head {          spinlock_t lock;          struct list_head task_l
linux 等待队列
03-27
总结来说，Linux等待队列是内核中用于进程同步的关键工具，它有效地管理了系统资源的分配，确保了进程间协作的正确性和效率。通过理解和运用等待队列，开发者可以编写出更高效、更稳定的内核级程序，特别是在处理...
Linux的等待队列介绍
05-10
Linux 等待队列介绍 Linux 等待队列是 Linux 操作系统中的一种机制，用于管理和维护一些阻塞（休眠）进程。当一个设备没有可读数据时，读进程可以阻塞，等待写进程写入数据。等待队列是一个进程链表，包含了等待...
linux-等待队列（Wait Queue）
最新发布
weixin_43412488的博客
12-13 1539
Wait Queue
Linux 等待队列
shangyaowei的专栏
12-19 394
在阅读Tun驱动时看到，有一些类似 add_wait_queue 的函数，这些函数正是执行等待队列的相关操作，要说等待队列还得从内核进程调度说起，内核调度系统内进程，分配时间片，但是有些进程如从网卡中读数据，在 网卡有数据到达之前进程处于阻塞状态，如果此时给相应进程分配时间片做调度，无疑是浪费系统资源，所以系统内每个进程都有自己的状态标志 task->state，这些状态定义于文件 include
Linux驱动---等待队列
qq_49079545的博客
08-23 668
1、等待队列 waitqueue（等待队列）就是内核用于管理等待资源的进程，当某个进程获取的资源没有准备好的时候，可以通过调用add_wait_queue()函数把进程添加到waitqueue中，然后切换到其他进程继续执行。 当资源准备好，由资源提供方通过调用wake_up()函数来唤醒等待的进程 2、定义 定义头文件 #include <linux/wait.h> 定义实例 wait_queue_head_t wq; init_waitqueue_head(&wq); 3、阻塞接口
Linux 等待队列
weixin_41028621的博客
02-10 253
了解linux 等待队列 1.概述   While writing modules there might be situations where one might have to wait for input some condition to occur before proceeding further. Tasks that need such behavior can make u...
linux 等待队列 第三篇
北落师门'的专栏
07-11 819
1、为什么要使用等待队列？等待队列就是阻塞型字符设备驱动的必需品。阻塞型就是说某个设备可读或者可写，但是呢，某个时候这个设备没有东西给你读，但你的应用程序（进程）操作却要向设备去读取数据，那没办法，要么就出错，要么就阻塞着在那里等着要读取数据。一旦设备有东西可以给你读了，进程就可以继续进行读操作了。 2、定义并初始化等待队列。     (1) 定义"等待队列头"         wait_
Linux驱动之等待队列
qq_53221728的博客
04-17 1206
Linux驱动之等待队列。定时器按键消抖、
Linux驱动 等待队列
10-17
Linux驱动中的等待队列是一种同步机制，用于在驱动程序中等待某些事件的发生。当某个事件未发生时，驱动程序可以将自己加入等待队列中，然后进入睡眠状态，直到事件发生并唤醒等待队列中的进程。 等待队列通常与...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值