Linux内核中的PID散列表实例

开发平台：基于虚拟机的Ubuntu 11.04

    内核源码：linux-2.6.38.8.tar.bz2

    目标平台：ARM体系结构

    参考文献：《深入Linux内核架构》

  

    关于散列表的概念可以参考博文《散列表的基本概念及其运算》。

    1、PID散列表

    PID散列表是在系统启动过程中通过pidhash_init函数（被start_kernel函数所调用）所创建的。

    PID散列表实际上就是一个像struct hlist_head pid_hash[i]这样的数组，其中i的大小由alloc_large_system_hash函数所确定，最大取值为4096，最小值为16。 

 /* linux-2.6.38.8/kernel/pid.c */
 void __init pidhash_init(void)
 {
     int i, pidhash_size;

     pid_hash = alloc_large_system_hash("PID", sizeof(*pid_hash), 0, 18,
                        HASH_EARLY | HASH_SMALL,
                        &pidhash_shift, NULL, 4096);
     pidhash_size = 1 << pidhash_shift;

     for (i = 0; i < pidhash_size; i++)
         INIT_HLIST_HEAD(&pid_hash[i]);
 }

    其中的alloc_large_system_hash函数能够根据机器物理内存的大小灵活地分配散列表的存储空间，以及改变pidhash_shift变量的默认值（默认值为4），从而确定pid_hash数组的大小（pidhash_size）。

    最后，pidhash_init函数通过宏INIT_HLIST_HEAD把pid_hash数组的每个元素（struct hlist_head类型的变量）都初始化为空指针。

    alloc_large_system_hash函数的实现比较复杂，没有时间也没有必要去分析它的每个语句，可以通过其中的打印语句来查看系统中的PID散列表到底有多大。 

 /* linux-2.6.38.8/mm/page_alloc.c */
     printk(KERN_INFO "%s hash table entries: %ld (order: %d, %lu bytes)\n",
            tablename,
            (1UL << log2qty),
            ilog2(size) - PAGE_SHIFT,
            size);

    例如，在基于虚拟机的Ubuntu 11.04中，当它的物理内存为512MB时，PID散列表的表项为2048个；当把物理内存修改为1GB时，PID散列表的表项提升到最大值4096个。 

 //512MB物理内存
 $ dmesg | grep "PID hash table entries"
 [    0.000000] PID hash table entries: 2048 (order: 1, 8192 bytes)
 //1GB物理内存
 $ dmesg | grep "PID hash table entries"
 [    0.000000] PID hash table entries: 4096 (order: 2, 16384 bytes)

    2、散列函数

    PID散列表的散列函数为pid_hashfn，定义在linux-2.6.38.8/kernel/pid.c文件中。 

 #define pid_hashfn(nr, ns)  \
     hash_long((unsigned long)nr + (unsigned long)ns, pidhash_shift)

 /* linux-2.6.38.8/include/linux/hash.h */
 #define hash_long(val, bits) hash_32(val, bits)

 #define GOLDEN_RATIO_PRIME_32 0x9e370001UL

 static inline u32 hash_32(u32 val, unsigned int bits)
 {
     /* On some cpus multiply is faster, on others gcc will do shifts */
     u32 hash = val * GOLDEN_RATIO_PRIME_32;

     /* High bits are more random, so use them. */
     return hash >> (32 - bits);
 }

    散列函数pid_hashfn先使关键字（nr和ns的和）乘以0x9e370001UL，然后取乘积的低pidhash_shift位（即bit[0]到bit[pidhash_shift-1]）。例如，对于拥有2048个表项的PID散列表，散列函数pid_hashfn的返回值（取乘积的低11位）最终都会落在0到2047之间。

    3、处理冲突

    PID散列表采用链地址法来处理冲突。

    4、PID散列表的运算函数

    在介绍PID散列表的运算函数之前，先介绍一下相关的结构体。

    struct pid是内核对PID的内部表示，而struct upid则表示特定的命名空间中可见的信息。 

 /* linux-2.6.38.8/include/linux/pid.h */
 enum pid_type
 {
     PIDTYPE_PID,
     PIDTYPE_PGID,
     PIDTYPE_SID,
     PIDTYPE_MAX
 };

 struct upid {
     /* Try to keep pid_chain in the same cacheline as nr for find_vpid */
     int nr;
     struct pid_namespace *ns;
     struct hlist_node pid_chain;
 };

 struct pid
 {
     atomic_t count;
     unsigned int level;
     /* lists of tasks that use this pid */
     struct hlist_head tasks[PIDTYPE_MAX];
     struct rcu_head rcu;
     struct upid numbers[1];
 };

    在struct upid中，nr表示ID（这里ID的类型有三种，定义在pid_type枚举中）的数值，ns是指向该ID所属命名空间的指针，所有的upid实例都通过pid_chain成员链接到pid_hash散列表中。

    在struct pid中，count表示一个引用计数器，level表示该进程的命名空间在命名空间层次结构中的深度，而numbers是一个struct upid实例的数组，每个数组项（形式上只有一个数组项，但实际上可以根据需要进行扩展）都对应着一个命名空间。Tasks是共享此struct pid实例的所有进程的链表表头，其中的进程通过它的pids[type]成员来构建链接。在Linux内核中，通过attach_pid函数来建立它们之间的链接。 

 /* linux-2.6.38.8/include/linux/pid.h */
 struct pid_link
 {
     struct hlist_node node;
     struct pid *pid;
 };

 /* linux-2.6.38.8/include/linux/sched.h */
 struct task_struct {
     ...

     struct pid_link pids[PIDTYPE_MAX];

     ...
 }

 /* linux-2.6.38.8/kernel/pid.c */
 void attach_pid(struct task_struct *task, enum pid_type type,
         struct pid *pid)
 {
     struct pid_link *link;

     link = &task->pids[type];
     link->pid = pid;
     hlist_add_head_rcu(&link->node, &pid->tasks[type]);
 }

    以上所述各种结构体的关系如下图所示（图片修改自《professional linux kernel architecture》）：

 

    在Linux内核中，使用过散列函数pid_hashfn的只有alloc_pid和find_pid_ns两个函数而已。

    （1）、插入运算

    alloc_pid函数用于创建struct pid结构体实例。 

 /* linux-2.6.38.8/kernel/pid.c */
 struct pid *alloc_pid(struct pid_namespace *ns)
 {
     struct pid *pid;
     enum pid_type type;
     int i, nr;
     struct pid_namespace *tmp;
     struct upid *upid;

     pid = kmem_cache_alloc(ns->pid_cachep, GFP_KERNEL);
     if (!pid)
         goto out;

     tmp = ns;
     for (i = ns->level; i >= 0; i--) {
         nr = alloc_pidmap(tmp);
         if (nr < 0)
             goto out_free;

         pid->numbers[i].nr = nr;
         pid->numbers[i].ns = tmp;
         tmp = tmp->parent;
     }

     get_pid_ns(ns);
     pid->level = ns->level;
     atomic_set(&pid->count, 1);
     for (type = 0; type < PIDTYPE_MAX; ++type)
         INIT_HLIST_HEAD(&pid->tasks[type]);

     upid = pid->numbers + ns->level;
     spin_lock_irq(&pidmap_lock);
     for ( ; upid >= pid->numbers; --upid)
         hlist_add_head_rcu(&upid->pid_chain,
                 &pid_hash[pid_hashfn(upid->nr, upid->ns)]);
     spin_unlock_irq(&pidmap_lock);

 out:
     return pid;

 out_free:
     while (++i <= ns->level)
         free_pidmap(pid->numbers + i);

     kmem_cache_free(ns->pid_cachep, pid);
     pid = NULL;
     goto out;
 }

    起始于建立进程的命名空间，一直到初始的全局命名空间，内核会为其中的每个命名空间分别创建一个局部PID，并把它们（用struct upid表示）都添加到pid_hash散列表中。

    （2）、查找运算

    find_pid_ns函数根据PID和命名空间指针来查找相应的struct pid实例。 

 /* linux-2.6.38.8/kernel/pid.c */
 struct pid *find_pid_ns(int nr, struct pid_namespace *ns)
 {
     struct hlist_node *elem;
     struct upid *pnr;

     hlist_for_each_entry_rcu(pnr, elem,
             &pid_hash[pid_hashfn(nr, ns)], pid_chain)
         if (pnr->nr == nr && pnr->ns == ns)
             return container_of(pnr, struct pid,
                     numbers[ns->level]);

     return NULL;
 }

    其中，首先使用散列函数pid_hashfn确定所查找结点在散列表pid_hash中的表头，然后遍历表头所指向的链表，当nr和ns都匹配时，即找到了所需的struct upid结点，最后根据struct upid结点通过container_of宏获得包含它的struct pid实例。