• 好好学习,天天向上~
  • 欢迎欢迎~

linux学习14,进程的睡眠与唤醒

linux笔记 lcc 273℃ 0评论

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学习14,进程的睡眠与唤醒 - 刘冲的博客(https://blog.popkx.com) 原创版权所有,转载请注明出处。
点赞 (1)分享 (0)
发表我的评论
取消评论
表情     5 + 2 = ? (必填)