Linux内核学习笔记之进程管理2—进程的组织形式

Linux内核学习笔记之进程管理2—进程的组织形式
1. 进程标识符构成的哈希表
内核使用一个进程描述符来表示一个进程,因此通过进程描述符的地址来访问一个进程是最方便的. 这里主要是用哈希表来完成进程号到进程描述符地址之间的映射.
内核中设置了PIDTYPE_MAX个不同的哈希表(4个),这四个哈希表保存在数组pid_hash中,
static struct hlist_head *pid_hash[PIDTYPE_MAX];
pid_type是一个枚举内型。
enum pid_type
{
PIDTYPE_PID,//进程号哈希表
PIDTYPE_TGID,//线程组号哈希表
PIDTYPE_PGID,//进程组号哈希表
PIDTYPE_SID,//会话号表
PIDTYPE_MAX
};
在进程描述符中有一个成员变量 pids，定义如下：
struct pid pids[PIDTYPE_MAX];
struct pid{
int nr;
struct hlist_node pid_chain;
struct list_head pid_list;
};
pid_chain构成一个链表，表中的nr值不同，哈希函数将这些nr值映射到哈希表中的同一位置，这个链表就是主链。（nr值本身就是进程号）
pid_list将具有相同nr值的进程联系在一起构成从链。例如可以讲同一个线程组的所有线程联系起来。



pid_hashfn(x) 负责进程号映射到哈希表中的位置。理论上哈希函数何以直接查找哈希表，但是哈希函数存在冲突问题，linux内核提供了哈希查找函数find_pid().（kernel/pid.c中）

struct pid * fastcall find_pid(enum pid_type type, int nr)

{

struct hlist_node *elem;

struct pid *pid;

hlist_for_each_entry(pid, elem,

&pid_hash[type][pid_hashfn(nr)], pid_chain) {//第type个哈希表中的第//pid_hashfn(nr)个元素。

if (pid->nr == nr)

return pid;

}

return NULL;

}

在创建进程是又设计到向哈希表中添加进程，有函数attach_pid()提供（kernel/pid.c中）

nr值不存在是直接插入到nr对应链表的表头

当nr存在时插入对应从表的表尾。

int fastcall attach_pid(task_t *task, enum pid_type type, int nr)

{

struct pid *pid, *task_pid;

task_pid = &task->pids[type];

pid = find_pid(type, nr);

if (pid == NULL) {

hlist_add_head(&task_pid->pid_chain,

&pid_hash[type][pid_hashfn(nr)]);

INIT_LIST_HEAD(&task_pid->pid_list);

 } else {

INIT_HLIST_NODE(&task_pid->pid_chain);

list_add_tail(&task_pid->pid_list, &pid->pid_list);

  }

task_pid->nr = nr;

return 0;

}

进程销毁时从哈希表中移除进程，由函数detach_pid()完成（kernel/pid.c中）

void fastcall detach_pid(task_t *task, enum pid_type type)

{

int tmp, nr;

nr = __detach_pid(task, type);//解除进程task与第type个哈希表之间的关联

if (!nr)

return;

for (tmp = PIDTYPE_MAX; --tmp >= 0; )

if (tmp != type && find_pid(tmp, nr))

        return;

free_pidmap(nr);//释放该进程号nr

}

2. 所有进程构成的双向链表
进程描述符中有成员变量 struct list_head tasks。可以构成双向链表。
在进程调度是利用该链表来查找进程显然是不合理的，于是linux内核有构建了新的数据结构提高调度效率。

3. 执行态进程组成的运行队列
Linux2.6内核采用了新的调度机制(与2.4相比)，实现了O(1)复杂度。采用了新的运行队列实现了新的调度算法。内核为每个处理器都设置了一个运行队列。
O(1)复杂度的调度算法的核心数据结构是—-运行队列 struct runqueue；（定义在/kernel/sched.c）

其中有一个实现O(1)复杂度的关键成员变量优先级数组：

prio_array_t  *active, *expired, arrays[2];

active 和 expired 分别指向活动和超时的优先级数组，arrays[2]用于存储着两个优先级数组。每个进程在时间片用完后，根据优先级重新分配时间片，优先级会在每次进程切换时重新计算，然后将其移到expried优先级数组中，当active数组中没有活动进程是，交换两个指针指向的数组。这是linux2.6实现实现O(1)复杂度调度算法的基础。

优先级数组定义如下：（定义在/kernel/sched.c）

struct prio_array {

unsigned int nr_active;//该优先级数组中可运行的进程数

unsigned long bitmap[BITMAP_SIZE];//优先级位图

struct list_head queue[MAX_PRIO];//可执行进程队列，为每一个优先级设置一个可执行进程队列

};

大概过程如下：

当进程被创建并投入运行时，首先将进程插入到对应的可执行队列的对尾，然后根据进程的优先级设置对应的优先级位图，例如优先级为N，就设置优先级位图的第N位，表示该优先级进程队列不为空。

当调度时，首先获取优先级位图中第一个不为0的bit为的序号，该序号指明了当前最高优先级进程所在的可执行队列，相应的可执行队列的第一个进程也就是“合适”的进程。

大致如下：

array = rq->active;

idx = sched_find_first_bit( array->bitmap );
queue = array->queue + idx;
next = list_entry( queue->next, task_t, run_list);//next指向“合适“的进程。

4. 阻塞态进程构成的等待队列

Linux内核为每一个临界资源设置了一个等待队列，在进程无法获取临界资源时就睡眠在该等待队列上。
①等待队列
wait_queue_head_t 表示一个等待队列/include/linux/wait.h

struct __wait_queue_head {

spinlock_t lock;

struct list_head task_list;

};

typedef struct __wait_queue_head wait_queue_head_t;

②等待队列节点

struct __wait_queue {

unsigned int flags;//唤醒方式

#define WQ_FLAG_EXCLUSIVE       0x01

void *private;//保存睡眠进程描述符地址

wait_queue_func_t func;//唤醒方法

  struct list_head task_list;//

};

唤醒方式有 WQ_FLAG_EXCLUSIVE 或者 0；
WQ_FLAG_EXCLUSIVE：表示节点对应进程对临界资源使用具有排他性。在唤醒是会唤醒所有非排他性进程和一定数量的排他性进程。

③睡眠在等待队列中
进程访问临界资源而阻塞时，先设置自己的状态为睡眠态（中断或者不可中断），然后在该临界资源的等待队列中睡眠，最后才释放处理器，等待该资源可用。
首先初始化等待队列节点（include/linux/wait.h）

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;

}

然后插入到等待队列

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);

}

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 首先清唤醒方式，在后插入到对首

add_wait_queue_exclusive先设置唤醒方式，然后插入到对尾。这样就将等待队列中的链表一分为二，前半部分为没有设置WQ_FLAG_EXCLUSIVE,后半部分为设置了WQ_FLAG_EXCLUSIVE;

的节点。这给后面的唤醒带来了好处。

④唤醒
Linux2.6内核提供了8个宏来唤醒等待队列中的进程。他们都是基于函数__wake_up_common
位于ernel/sched.c

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;

unsigned flags;

curr = list_entry(tmp, wait_queue_t, task_list);

flags = curr->flags;

if (curr->func(curr, mode, sync, key) &&

(flags & WQ_FLAG_EXCLUSIVE) &&

!--nr_exclusive)

break;

}

}

ANSI C标准定义逻辑与的运算规则，前面的为真才会继续运算后面的，所以上面的if可以实现唤醒全部得非排他性进程和nr_exclusive个排他性进程。