Linux中等待队列机制分析

最新推荐文章于 2024-09-23 13:05:18 发布

关耳君2022

最新推荐文章于 2024-09-23 13:05:18 发布

阅读量826

点赞数

分类专栏： Linux驱动开发 Linux/Unix系统编程文章标签： linux struct list 任务数据结构 up

Linux驱动开发同时被 2 个专栏收录

19 篇文章 0 订阅

订阅专栏

Linux/Unix系统编程

10 篇文章 0 订阅

订阅专栏

在软件开发中任务经常由于某种条件没有得到满足而不得不进入睡眠状态，然后等待条件得到满足的时候再继续运行，进入运行状态。这种需求需要等待队列机制的支持。Linux中提供了等待队列的机制，该机制在内核中应用很广泛。在内核里面，等待队列是有很多用处的，尤其是在中断处理、进程同步、定时等场合。可以使用等待队列在实现阻塞进程的唤醒。它以队列为基础数据结构，与进程调度机制紧密结合，能够用于实现内核中的异步事件通知机制，同步对系统资源的访问等。

在Linux内核中使用等待队列的过程很简单，首先定义一个wait_queue_head，然后如果一个task想等待某种事件，那么调用wait_event（等待队列，事件）就可以了。

在这个链表中，有两种数据结构：等待队列头（wait_queue_head_t）和等待队列项（wait_queue_t）。等待队列头和等待队列项中都包含一个list_head类型的域作为"连接件"。由于我们只需要对队列进行添加和删除操作，并不会修改其中的对象（等待队列项），因此，我们只需要提供一把保护整个基础设施和所有对象的锁，这把锁保存在等待队列头中，为wq_lock_t类型。在实现中，可以支持读写锁（rwlock）或自旋锁（spinlock）两种类型，通过一个宏定义来切换。如果使用读写锁，将wq_lock_t定义为rwlock_t类型；如果是自旋锁，将wq_lock_t定义为spinlock_t类型。无论哪种情况，分别相应设置wq_read_lock、wq_read_unlock、 wq_read_lock_irqsave、wq_read_unlock_irqrestore、wq_write_lock_irq、wq_write_unlock、wq_write_lock_irqsave和wq_write_unlock_irqrestore等宏。

一、Linux中等待队列的实现

等待队列应用广泛，但是内核实现却十分简单。定义在/include/linux/wait.h，其涉及到两个比较重要的数据结构：

1) __wait_queue_head，该结构描述了等待队列的链头，其包含一个链表和一个原子锁，结构定义如下：

struct __wait_queue_head {
              spinlock_t lock;                    /* 保护等待队列的原子锁 */
              struct list_head task_list;              /* 等待队列 */
};

typedef struct __wait_queue_head wait_queue_head_t;

在/include/linux/list.h中：

struct list_head {
struct list_head *next, *prev;
};

其中，spinlock_t lock字段——在对task_list操作的过程中，使用该锁实现对等待队列的互斥访问；srtuct list_head task_list——双向循环链表，存放等待的进程。

2)__wait_queue，该结构是对一个等待任务的抽象。每个等待任务都会抽象成一个wait_queue，并且挂载到wait_queue_head上。该结构定义如下：

struct __wait_queue {
       unsigned int flags;
	   #define WQ_FLAG_EXCLUSIVE 0x01
       void *private;                       /* 通常指向当前任务控制块 */
       /* 任务唤醒操作方法，该方法在内核中提供，通常为autoremove_wake_function */
       wait_queue_func_t func;             
       struct list_head task_list;              /* 挂入wait_queue_head的挂载点 */
};

typdef struct__wait_queue wait_queue_t;

Linux中等待队列的实现思想如下图所示，当一个任务需要在某个wait_queue_head上睡眠时，将自己的 进程控制块信息封装到wait_queue中，然后挂载到wait_queue的链表中，执行调度睡眠。当某些事件发生后，另一个任务（进程）会唤醒wait_queue_head上的某个或者所有任务，唤醒工作也就是将等待队列中的任务 设置为可调度的状态，并且从队列中删除。

使用等待队列时首先需要定义一个wait_queue_head，这可以通过DECLARE_WAIT_QUEUE_HEAD宏来完成，这是静态定义的方法。该宏会定义一个wait_queue_head，并且初始化结构中的锁以及等待队列。当然，动态初始化的方法也很简单，初始化一下锁及队列就可以了。

一个任务需要等待某一事件的发生时，通常调用wait_event，该函数会定义一个wait_queue，描述等待任务，并且用当前的进程描述块初始化wait_queue，然后将wait_queue加入到wait_queue_head中。函数实现流程说明如下：

1、用当前的进程描述块（PCB）初始化一个wait_queue描述的等待任务。

2、在等待队列锁资源的保护下，将等待任务加入等待队列。

3、判断等待条件是否满足，如果满足，那么将等待任务从队列中移出，退出函数。

4、如果条件不满足，那么任务调度，将CPU资源交与其它任务。

5、当睡眠任务被唤醒之后，需要重复（2）、（3）步骤，如果确认条件满足，退出等待事件函数。

二、操作

1、定义并初始化等待队列头：

　　(1)

　　wait_queue_head_t my_queue;

　　init_waitqueue_head(&my_queue);

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

　　(2)

　　DECLARE_WAIT_QUEUE_HEAD(my_queue);

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

2、定义等待队列项：

　　DECLARE_WAITQUEUE(name,tsk);

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

在/include/linux/wait.h中：

#define DECLARE_WAITQUEUE(name, tsk)

wait_queue_t name = __WAITQUEUE_INITIALIZER(name , tsk)

wait_queue_t类型定义如下：

struct __wait_queue {
　　unsigned int flags;
　　#define WQ_FLAG_EXCLUSIVE 0x01
　　void *private;
　　wait_queue_func_t func;
　　struct list_head task_list;
};

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

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

　　(1)add_wait_queue()函数：

void fastcall 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);
}

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

void fastcall add_wait_queue_exclusive(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_tail(q, wait);
　　spin_unlock_irqrestore(&q->lock, flags);
}

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

(2)remove_wait_queue()函数：

　　void fastcall 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);
}

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

4、等待事件：

　　(1)wait_event()宏：

#define wait_event(wq, condition)
　do {
　　if (condition)
　　break;
　　__wait_event(wq, condition);
　} while (0)

　　#define __wait_event_timeout(wq, condition, ret)
　do {
　　DEFINE_WAIT(__wait);
　　for (;;) {
　　prepare_to_wait(&wq, &__wait, TASK_UNINTERRUPTIBLE);
　　if (condition)
　　break;
　　ret = schedule_timeout(ret);
　　if (!ret)
　　break;
　}
　　finish_wait(&wq, &__wait);
} 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()函数:

#define wake_up(x) __wake_up(x, TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE, 1, NULL)
void fastcall __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);
　　spin_unlock_irqrestore(&q->lock, flags);
}
　　static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,
　　int nr_exclusive, int sync, void *key)
{
　　struct list_head *tmp, *next;
　　list_for_each_safe(tmp, next, &q->task_list)

   {
　　wait_queue_t *curr = list_entry(tmp, wait_queue_t, task_list);
　　unsigned flags = curr->flags;
　　if (curr->func(curr, mode, sync, key) &&(flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
　　break;
   }
}

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

　　(2)wake_up_interruptible()函数:

　　#definewake_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)

   #define wake_up_all(x) __wake_up(x, TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE, 0, 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)

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

　　6、在等待队列上睡眠：

　　(1)sleep_on()函数:

void __sched sleep_on(wait_queue_head_t *q)
{
　　unsigned long flags;
　　wait_queue_t wait;
　　init_waitqueue_entry(&wait, current);
　　current->state = TASK_UNINTERRUPTIBLE;
　  sleep_on_head(q, &wait, &flags);
　　schedule();
　　sleep_on_tail(q, &wait, &flags);
}

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

　　(2)sleep_on_timeout()函数：

long __sched sleep_on_timeout(wait_queue_head_t *q, long timeout)
{
　　unsigned long flags;
　　wait_queue_t wait
　　init_waitqueue_entry(&wait, current);
　　current->state = TASK_UNINTERRUPTIBLE;
　　sleep_on_head(q, &wait, &flags);
　　timeout = schedule_timeout(timeout);
　　sleep_on_tail(q, &wait, &flags);
　　return timeout;
}

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

　　(3)interruptible_sleep_on()函数：

void __sched interruptible_sleep_on(wait_queue_head_t *q)
{
　　 unsigned long flags;
　　 wait_queue_t wait;
　　 init_waitqueue_entry(&wait, current);
　　 current->state = TASK_INTERRUPTIBLE;
　　 sleep_on_head(q, &wait, &flags);
　　 schedule();
　　 sleep_on_tail(q, &wait, &flags);
}

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

　(4)interruptible_sleep_on_timeout()函数：

　　long __sched interruptible_sleep_on_timeout(wait_queue_head_t *q, long timeout)
　{
　　unsigned long flags;
　  wait_queue_t wait;
　　init_waitqueue_entry(&wait, current);
　　current->state = TASK_INTERRUPTIBLE;
　　sleep_on_head(q, &wait, &flags);
　　timeout = schedule_timeout(timeout);
　　sleep_on_tail(q, &wait, &flags);
　　return timeout;
　　}

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

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