linux进程调度 - 组织进程

1. 进程的运行状态

---

进程的运行状态有下面这么几种：

进程运行状态 描述 TASK_RUNNING 运行的进程被设置 TASK_INTERRUPTIBLE 进程被挂起，除非有硬件中断或者信号传递来唤醒进程 TASK_UNINTERRUPTIBLE 与可中断类似，但是信号不能唤醒进程 TASK_STOPPED 进程的执行被暂停

进程被创建后，会被设置各种运行状态，然后会被不同方式进行处理，分下面两种情况

1.1 可运行进程处置方式

TASK_RUNNING状态的进程会被挂入一个运行队列的链表中，然后被调度程序来选择合适的时机进行调度运行，这个运行队列链表是runqueues，会在以后的文章中介绍

1.2 不运行进程处置方式

当要把其他状态的进程分组时，不同的状态要求不同的处理，对于处于暂停、僵死、死亡状态的进程没有专门的链表来组织它们，对于处于TASK_INTERRUPTIBLE、TASK_UNINTERRUPTIBLE状态的进程会把它们加入不同的等待队列中，等待合适的条件来把他们转化为TASK_RUNNING状态并加入运行队列，然后被调度执行。

2. 进程等待队列

---

等待队列在内核中有很多用途，比如在中断处理、进程同步及定时等，等待队列由双向链表实现，每个等待队列都有一个等待队列头（wait queue head），数据结构如下所示：

typedef struct __wait_queue_head wait_queue_head_t;struct __wait_queue_head {    spinlock_t      lock;    struct list_head    task_list;-----------等待队列链表头，队列元素都加入此list};

每个等待队列头中后期都会加入进程，这些进程由**队列元素**wait_queue_t来包装。

typedef struct __wait_queue wait_queue_t;struct __wait_queue {    unsigned int        flags;---------------区分互斥进程（1）和非互斥进程（0）    void            *private;----------------一般是task_struct    wait_queue_func_t   func;----------------唤醒此队列元素的函数    struct list_head    task_list;-----------list};

一般来说互斥进程会加入到队尾，非互斥进程在队列头

2.1 初始化等待队列头

定义的每个队列元素，都会加入一个已经初始化好的等待队列头中，初始化wait_queue_head_t的宏定义为DECLARE_WAIT_QUEUE_HEAD(name)，如下所示：

#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.2 初始化队列元素

初始化一个wait_queue_t的宏定义为#define DECLARE_WAITQUEUE(name, tsk)，第二个参数是进程描述符，如下所示：

#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 } }

另外还有一些函数能初始化wait_queue_t，如下所示：

static inline void init_waitqueue_entry(wait_queue_t *q, struct task_struct *p){    q->flags    = 0;    q->private  = p;    q->func     = default_wake_function;----------------内核默认的一个唤醒函数}static inline voidinit_waitqueue_func_entry(wait_queue_t *q, wait_queue_func_t func){-------------------------------------------------------和进程无关的队列元素    q->flags    = 0;    q->private  = NULL;    q->func     = func;}

当然也可以自定义函数来初始化wait_queue_t

3. 把进程加入等待队列

---

等待队列头和队列元素初始化后，就可以把前者加入后者中了，相应会有多个函数能做这项任务

1. 非互斥进程调用的函数

（kernel/sched/wait.c : wait.h）

extern void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait);上面的函数最后会调用函数__add_wait_queuestatic inline void __add_wait_queue(wait_queue_head_t *head, wait_queue_t *new){    list_add(&new->task_list, &head->task_list);}

1. 互斥进程调用的函数：

（kernel/sched/wait.c : wait.h）

extern void add_wait_queue_exclusive(wait_queue_head_t *q, wait_queue_t *wait);上面的函数最后会调用函数__add_wait_queue_tailstatic inline void __add_wait_queue_tail(wait_queue_head_t *head,                     wait_queue_t *new){    list_add_tail(&new->task_list, &head->task_list);}

4. 唤醒等待队列中的进程

---

唤醒等待队列中的元素有一些宏定义：

#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, 1)#define wake_up_all_locked(x)       __wake_up_locked((x), TASK_NORMAL, 0)#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 -> __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;        if (curr->func(curr, mode, wake_flags, key) &&                (flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)            break;    }}

遍历链表中的每项队列元素，执行其func函数，默认的一个唤醒函数是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);}

change log

---

date content linux kernel 2016.11.20 原始写作 linux4.6.3