eagain（linux学习14）

linux 中进程的状态

第10节曾提到，进程一共只有 5 种状态，也必定是这 5 种状态之一：

TASK_RUNNING，表示进程是可执行的，或者正在运行，或者正在运行队列里排队等待运行。TASK_INTERRUPTIBLE，表示进程正在睡眠，并且可能随时被唤醒信号唤醒，唤醒后，进程会被设置为 TASK_RUNNING。TASK_UNINTERRUPTIBLE，表示进程正在睡眠，不会被信号唤醒。__TASK_TRACED，表示进程正在被其他进程跟踪，例如正在被 gdb 调试的进程就会是这个状态。__TASK_STOPPED，表示进程停止执行，不能被投入运行。

现在来设想下面这种情况：某个进程使用了文件系统，正在阻塞等待磁盘返回数据，这个过程可能需要若干 ms。该进程一直处于运行状态，但是只是等待数据，没有做任何其他事，此时 cpu 的性能就被白白浪费了，整个系统的效率也就非常低下。

若干毫秒对于人类来说可能稍纵即逝，但是对于 cpu 这种常常以 ns 衡量运算时间的器件来说，就太漫长了。

进程的睡眠状态非常重要

所以，linux 中进程的睡眠状态也是非常重要的。结合上一节的说法，睡眠的进程被从可执行红黑树中移出，所以 linux 内核不会调度它投入运行，也就不会消耗过多 cpu 的性能。

TASK_INTERRUPTIBLE 和 TASK_UNINTERRUPTIBLE 状态的进程，会被放入同一个等待队列，等待特定的事件到来，才会被 linux 内核继续唤醒调度运行。

特定的事件例如：磁盘数据到达、等待的信号到达等。

linux 内核中，进程睡眠的源码分析

那么，linux 内核是如何实现进程睡眠的呢？现在从C语言源码分析。请看：

- 50 struct __wait_queue_head { | 51 spinlock_t lock; | 52 struct list_head task_list; | 53 }; 54 typedef struct __wait_queue_head wait_queue_head_t;

内核正是使用 wait_queue_head_t 结构体表示等待队列的，它的结构非常简单，就是一个带有自旋锁的链表而已。内核设置进程睡眠，大体框架都是相似的，请看：

wait_queue_head_t wait; init_waitqueue_head(&wait); add_wait_queue(q, &wait); while(!condition){ prepare_to_wait(&q, &wait, TASK_INTERRUPTIBLE); if(signal_pending(current)) /* 处理信号 */ schedule(); } finish_wait(&q, &wait); 以上代码假设 q 是进程睡眠的队列。

内核先使用 init_waitqueue_head() 函数初始化 wait， 然后调用 add_wait_queue() 函数将进程放入等待队列，它的C语言源码如下：

21 void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait) - 22 { | 23 unsigned long flags; | 24 | 25 wait->flags &= ~WQ_FLAG_EXCLUSIVE; | 26 spin_lock_irqsave(&q->lock, flags); | 27 __add_wait_queue(q, wait); | 28 spin_unlock_irqrestore(&q->lock, flags); | 29 }

变量 condition 表示要等待的条件，如果它发生了，则进程就不会再被设置成睡眠状态，这是 linux 内核会调用 finish_wait() 函数结束等待，finish_wait() 函数的C语言定义如下：

104 void finish_wait(wait_queue_head_t *q, wait_queue_t *wait) - 105 { | 106 unsigned long flags; | 107 | 108 __set_current_state(TASK_RUNNING); |- 122 if (!list_empty_careful(&wait->task_list)) { || 123 spin_lock_irqsave(&q->lock, flags); || 124 list_del_init(&wait->task_list); || 125 spin_unlock_irqrestore(&q->lock, flags); || 126 } | 127 }

可以看出，finish_wait() 函数要做的工作很简单，它首先将进程设置为 TASK_RUNNING 状态，接着清理了相关的锁。

如果进程要等待的条件没有发生，那么 linux 内核将调用 prepare_to_wait() 函数将进程加入等待队列，它的C语言代码如下，请看：

66 void prepare_to_wait(wait_queue_head_t *q, wait_queue_t *wait, int state) - 68 { | 69 unsigned long flags; | 70 | 71 wait->flags &= ~WQ_FLAG_EXCLUSIVE; | 72 spin_lock_irqsave(&q->lock, flags); | 73 if (list_empty(&wait->task_list)) | 74 __add_wait_queue(q, wait); | 75 /* | 76 * don't alter the task state if this is just going to | 77 * queue an async wait queue callback | 78 */ | 79 if (is_sync_wait(wait)) | 80 set_current_state(state); | 81 spin_unlock_irqrestore(&q->lock, flags); | 82 }

这个函数也很简单，它处理了自旋锁，并且在恰当的时候把进程设置为睡眠状态（TASK_INTERRUPTIBLE 或 TASK_UNINTERRUPTIBLE 状态）。

如果该进程等待的条件一直没有发生，则 linux 内核会一直调用 schedule() 函数，从可执行红黑树中挑选一个进程投入运行。

实例，linux 中进程被设置睡眠状态

现在，对 linux 内核将进程加入睡眠的大框架已经了解了，来看一个实例——文件系统中的 inotify_read() 函数。它的功能就是从通知文件描述符中读取信息，C语言定义如下：

423 static ssize_t inotify_read(struct file *file, char __user *buf, 424 size_t count, loff_t *pos) - 425 { | 426 size_t event_size = sizeof (struct inotify_event); | 427 struct inotify_device *dev; | 428 char __user *start; | 429 int ret; | 430 DEFINE_WAIT(wait); | 431 | 432 start = buf; | 433 dev = file->private_data; | 434 |- 435 while (1) { || 436 int events; || 437 || 438 prepare_to_wait(&dev->wq, &wait, TASK_INTERRUPTIBLE); || 439 || 440 mutex_lock(&dev->ev_mutex); || 441 events = !list_empty(&dev->events); || 442 mutex_unlock(&dev->ev_mutex); ||- 443 if (events) { ||| 444 ret = 0; ||| 445 break; ||| 446 } || 447 ||- 448 if (file->f_flags & O_NONBLOCK) { ||| 449 ret = -EAGAIN; ||| 450 break; ||| 451 } || 452 ||- 453 if (signal_pending(current)) { ||| 454 ret = -EINTR; ||| 455 break; ||| 456 } || 457 || 458 schedule(); || 459 } | 460 | 461 finish_wait(&dev->wq, &wait); ...

这里我们只关心进程“睡眠”相关的代码。DEFINE_WAIT() 是一个宏，它的 C语言定义如下：

446 #define DEFINE_WAIT(name) \ - 447 wait_queue_t name = { \ | 448 .private = current, \ | 449 .func = autoremove_wake_function, \ | 450 .task_list = LIST_HEAD_INIT((name).task_list), \ | 451 }

容易看出，这个宏其实就是使用 wait_queue_t 结构体定义并且初始化了 wait。接着，函数进入了 while(1) 循环，因为有一些锁资源，所以这里不是按照前面介绍的 while(!condtion) 框架，而是使用 break 跳出循环，能够看出 inotify_read() 函数等待的事件在 dev->events 链表里，其他的都与前面讨论的框架一致，就不再赘述了。

唤醒进程

当进程等待的事件发生时，linux 内核要唤醒进程，将其加入可执行红黑树。这一过程是由 wake_up 宏实现的，它的C语言定义如下：

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

继续跟踪：

4316 void __wake_up(wait_queue_head_t *q, unsigned int mode, 4317 int nr_exclusive, void *key) - 4318 { | 4319 unsigned long flags; | 4320 | 4321 spin_lock_irqsave(&q->lock, flags); | 4322 __wake_up_common(q, mode, nr_exclusive, 0, key); | 4323 spin_unlock_irqrestore(&q->lock, flags); | 4324 } 4295 static void __wake_up_common(wait_queue_head_t *q, unsigned int mode, 4296 int nr_exclusive, int sync, void *key) - 4297 { | 4298 wait_queue_t *curr, *next; | 4299 |- 4300 list_for_each_entry_safe(curr, next, &q->task_list, task_list) { || 4301 unsigned flags = curr->flags; || 4302 || 4303 if (curr->func(curr, mode, sync, key) && || 4304 (flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive) || 4305 break; || 4306 } | 4307 }

关键就是 curr->func，这里C语言使用了面向对象的思想（详细可参照我的这篇文章:为C语言找一个对象）。func 的原型是什么呢？其实正是在 DEFINE_WAIT 宏里初始化时的 autoremove_wake_function() 函数，它的 C语言定义如下：

130 int autoremove_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key) - 131 { | 132 int ret = default_wake_function(wait, mode, sync, key); | 133 | 134 if (ret) | 135 list_del_init(&wait->task_list); | 136 return ret; | 137 } 4279 int default_wake_function(wait_queue_t *curr, unsigned mode, int sync, 4280 void *key) - 4281 { | 4282 return try_to_wake_up(curr->private, mode, sync); | 4283 }

继续跟踪，发现 linux 内核唤醒进程的核心函数是 try_to_wake_up() 函数，它的C语言定义如下，请看：

2078 static int try_to_wake_up(struct task_struct *p, unsigned int state, int sync) - 2079 { | 2080 int cpu, orig_cpu, this_cpu, success = 0; | 2081 unsigned long flags; | 2082 long old_state; | 2083 struct rq *rq; | 2084 | 2085 if (!sched_feat(SYNC_WAKEUPS)) | 2086 sync = 0; ... | 2151 out_running: | 2152 check_preempt_curr(rq, p); | 2153 | 2154 p->state = TASK_RUNNING; | 2155 #ifdef CONFIG_SMP | 2156 if (p->sched_class->task_wake_up) | 2157 p->sched_class->task_wake_up(rq, p); | 2158 #endif | 2159 out: | 2160 task_rq_unlock(rq, &flags); | 2161 | 2162 return success; | 2163 }

这个函数虽然很长，但是最核心的其实只有一行，就是将进程的状态设置为 TASK_RUNNING 状态。

至此，linux 内核中进程睡眠和唤醒的设计和实现，应该已经明白了。

欢迎在评论区一起讨论，质疑。文章都是手打原创（本文部分参考linux内核原理和设计），每天最浅显的介绍C语言、linux等嵌入式开发，喜欢我的文章就关注一波吧，可以看到最新更新和之前的文章哦。