在linux中，命名空间主要提供一种轻量级的资源虚拟，可以从不同方面来查看系统的全局属性，不同命名空间可以互相不干扰，为进程的一部分嗯。例如：同一个进程pid,可以被多个进程共享使用，可以查看同一用户的所有资源消费情况等等。

总体定义

1. struct user_namespace {
2. struct kref         kref;
3. struct hlist_head uidhash_table[UIDHASH_SZ];
4. struct user_struct *root_user;
5. }

1. struct user_struct {
2. atomic_t __count;//该结构体引用计数
3. atomic_t processes;//该用户拥有的进程数量
4. atomic_t sigpending;//该用户拥有的悬而未决的信号量数目
5. ….
6. unsigned long locked_shm;//锁住的共享页个数
7. //hash表所维护的信息
8. struct hlist_node uidhash_node;
9. uid_t uid;
10. …...
11. }

1. static struct user_namespace *clone_user_ns(struct user_namespace *old_ns)
2. {
3. struct user_namespace *ns;
4. struct user_struct *new_user;
5. int n;
6. ns = kmalloc(sizeof(struct user_namespace),GFP_KERNEL);
7. if(!ns)
8. return ERR_PTR(-ENOMEM);
9. kref_init(&ns->kref);
10. for(n=0; n< UIDHASH_SZ;++n)
11. INIT_HLIST_HEAD(ns->uidhash_table+n);
12. /*insert into new root user*/
13. ns->root_user = alloc_uid(ns,0);
14. if(!ns->root_user) {
15. kfree(ns);
16. return ERR_PTR(-ENOMEM);
17. }
18. new_user = alloc_uid(ns,current->uid);
19. if(!new_user) {
20. free_uid(ns->root_user);
21. kfree(ns);
22. return ERR_PTR(-ENOMEM);
23. }
24. switch(new_user);
25. return ns;
26. }

1. struct task_struct {
2. …..
3. pid_t pid;
4. pid_t tgid;
5. struct task_struct *group_leader;
6. struct list_head thread_group;
7. …..
8. }

1. struct signal_struct {
2. ….....
3. struct task_struct *curr_target;
4. union {
5. pid_t pgrp __deprecated;
6. pid_t __pgrp;
7. };
8. union {
9. pid_t session __deprecated;
10. pid_t __session;
11. };
12. ….....
13. }

1. [include/linux/pid_namespace.h]
2. //每个命名空间都包含一个所有pid的分配图，系统中各个命名空间互不交叉
3. struct pid_namespace {
4. struct kref kref;//进程的引用计数
5. struct pidmap pidmap[PID_ENTRIES];//pid分配图
6. int last_pid;
7. struct task_struct *child_reaper;//当前命名空间中waitpid角色的task
8. struct kmem_cache *pid_cachep;
9. int level;//当前pid_namespace的深度
10. struct pid_namespace *parent;//父pid_namespace
11. }

1. [kernel/pid.c]
2. struct pid_namespace init_pid_ns = {
3. .kref = {
4. .refcount = ATOMIC_INIT(2),
5. },
6. //可用pid：4KB 4*1024*8=32768
7. .pidmap = {
8. .pidmap = {
9. [ 0 … PIDMAP_ENTRIES – 1] = {
10. ATOMIC_INIT(BITS_PER_PAGE),NULL}
11. },
12. .last_pid = 0,
13. .level = 0,
14. .child_reaper = &init_task,//init_task监听该命名空间的所有task
15. }

1. [include/linux/pid.h]
2. struct upid
3. {
4. int nr;//真正的pid值
5. struct pid_namespace *ns;//该nr属于哪个pid_namespace
6. struct hlist_node pid_chain;//所有upid的hash链表 find_pid
7. }
8. //一个pid可以属于不同的级别，每一级别又包含一个upid
9. struct pid
10. {
11. atomic_t count;//引用计数
12. struct hlist_head tasks[PIDTYPE_MAX];//该pid被使用的task链表
13. struct rcu_head rcu;//互斥访问
14. int level;//该pid所能到达的最大深度
15. struct upid numbers[1];//每一层次(level)的upid
16. }

1. enum pid_type
2. {
3. PIDTYPE_PID,
4. PIDTYPE_PGID,
5. PIDTYPE_SID,
6. PIDTYPE_MAX
7. }

1. struct task_struct {
2. …...
3. struct pid_link pids[PIDTYPE_MAX];
4. …...
5. }

1. struct pid_link {
2. struct hlist_node node;//由于每个task包含多个pid(多个命名空间可见)，指向的是自己
3. struct pid    *pid;
4. }

1. static struct hlist_head *pid_hash;//双向hash链表
2. pid_hash是一个hlist_head数组，大小根据机器的内存配置，从16到4096,初始化代码如下：
3. [kernel/pid.c]
4. void __init pidhash_init(void)
5. {
6. int i, pidhash_size;
7. //#define PAGE_SHIFT 12
8. unsigned long megabytes = nr_kernel_pages >> (20-PAGE_SHIFT);
9. pidhash_shift = max(4,fls(megabytes * 4));
10. pidhash_shift = min(12,pidhash_shift);
11. //16项到4096项
12. pidhash_size = 1 << pidhash_shift;
13. ….....
14. pid_hash = alloc_bootmem(pidhash_size*sizeof(*(pid_hash)));
15. if(!pid_hash)
16. panic(“Could not alloc pidhash”);
17. for(i=0;i< pidhash_size;++i)
18. INIT_HLIST_HEAD(&pid_hash[i]);
19. }

当struct pid已经分配，需要链接到具体task中时，执行代码如下：

内核提供了大量的函数来进行pid到task之间的映射管理及维护,主要包括两部分:

1.指定局部数值pid，对应的命名空间，查找到对应的进程。

这种情况主要有以下几种情况：

1.获取与pid相关联的task,task_pid,task_tgid,task_pgrp,task_session用于不同类型的ID。

其它的也与上面的类似。

2.通过pid和命名空间namespace来查找进程的pid_t

内核还采用了另外的方法来访问进程的pid:

1.pid_vnr从id所属的命名空间中返回局部pid,如:

这些函数都是通过pid_nr_ns来实现的

2.pid_nr从init进程中获取全局pi

这两个函数实际都通过指明level级别(0表示全局)调用了函数pid_nr_ns,它则是通过nr_ns系列函数来进行访问，如:

这些函数也是通过pid_nr_ns来实现的。

另外，还可以通过pid中的数值id-nr和命名空间来获取对应的pid，如下:

2.指定一个进程，id类型，及命名空间，查找到对应的进程pid,如find_task系列函数：

这些函数都是通过find_task_by_pid_type_ns来实现的

而pid_task实现如下：

pid的分配