linux pid名字空间

最近看《深入理解linux内核架构》中pid名字空间一块，略有感悟。这里开门见山，直接来讲pid名字空间是如何实现的，以及如何使用。先看一幅图，图中描述了所使用的数据结构和他们的关系。



首先强调图中的几个比较容易搞混的字段。看task_struct中的struct pid_link *pids数组中，每个元素里有一个struct hlist_node node字段。也就是说，可以利用这个字段把task_struct加入到一个哈希表中。再看右边的struct pid结构中的struct hlist_head tasks[]数组，明显这个hlist_head,也就是表头，这个地方的每个数组元素都可以是一个链表。由于这里数据结构比较多，所以一定要注意是一个内结点，还是一个链表的头结点。

图中绿线（无箭头)表示头结点把中间结点链接成了一个链。而蓝色单箭头线表示，是只有一个指向目标结点的指针。蓝色双箭头线表示是双向链表。

为什么要搞这么复杂的结构呢？因为满足一些需求。

搞pid名字空间就是为了把一些进程隔离开来，让他们以为他们独占了整个系统，在虚拟化等中有应用。

还有，内核中经常需要由PID的数字值得到进程task_struct。（struct hlist_head *pid_hash的作用)。

需要由PID数字值得到进程组ID，会话ID。

当一个会话结束了，需要终止属于这个会话的所有进程。也就是要由会话ID找到所有属于这个会话的进程task_struct。(看看struct pid中有个SID字段，这里链接着属于这个PID的所有会话进程）。

linux用轻量级进程模拟线程，所以需要由线程组长ID找到所有属于这个进程的线程ID。

新创建一个进程是怎么影响名字空间的？

新建进程时的调用栈如下图。可以看出这是在创建内核线程。创建用户线程是调用fork()系统调用，这fork里也调用了do_fork()，也就是图中的do_fork(). do_fork中调用了copy_process函数，在这个函数中子进程复制了父进程的task_struct，其中就复制了task_struct中的struct pid_link pids[]数组。也就是说这时子进程与父进程有一样的PID，SID，GID。不过不用担心，这时子进程没有运行，在copy_process后边会重新给pids[PID].pid赋值。



在kernel/fork.c：copy_process函数中，依次调用了下列函数：

p = dup_task_struct(current);复制了父进程的PID，GID，SID。
if (pid != &init_struct_pid) {
retval = -ENOMEM;
pid = alloc_pid(p->nsproxy->pid_ns);//分配新的PID，包括在每个名字空间中看到的不同PID。
if (!pid)
goto bad_fork_cleanup_io;
if (clone_flags & CLONE_NEWPID) {
retval = pid_ns_prepare_proc(p->nsproxy->pid_ns);
if (retval < 0)
goto bad_fork_free_pid;
}
}
p->pid = pid_nr(pid);
p->tgid = p->pid;
if (clone_flags & CLONE_THREAD)
p->tgid = current->tgid;
//自己成了新的进程组长,但是在真正获取进程组ID时：task->group_leader->pids[PIDTYPE_PGID];
p->group_leader = p;
INIT_LIST_HEAD(&p->thread_group);
if (likely(p->pid)) {
list_add_tail(&p->sibling, &p->real_parent->children);
tracehook_finish_clone(p, clone_flags, trace);
if (thread_group_leader(p)) {
if (clone_flags & CLONE_NEWPID)
p->nsproxy->pid_ns->child_reaper = p;

p->signal->leader_pid = pid;
tty_kref_put(p->signal->tty);
p->signal->tty =tty_kref_get(current->signal->tty);
attach_pid(p, PIDTYPE_PGID, task_pgrp(current));

**//加入会话PID的task[PIDTYPE_SID]链表。**
attach_pid(p, PIDTYPE_SID, task_session(current));
list_add_tail_rcu(&p->tasks, &init_task.tasks);
__get_cpu_var(process_counts)++;
}
**//将自己加入struct pid的tasks[PIDTYPE_PID]链表。**
attach_pid(p, PIDTYPE_PID, pid);
nr_threads++;
}

每个进程有一个stuct pid结构，在这个结构中，tasks[]数组中有三个链表，第一个是PIDTYPE_PID链表，这个链表中只有一个进程x，也就是说每个进程有唯一一个struct PID.

第二个是PIDTYPE_PGID,这个链表中可能多于一个进程，多个进程可能属于同一个进程组，由此可见，组长进程退出后，这个struct结点不应该释放，直到进程组中所有进程退出。第三个是PIDTYPE_SID,这个与PGID一样，属于同一个会话的进程都在这个链表中。有了这些知识，上面的问题都可以迎刃而解了。

分配struct pid

下面代码在kernel/pid.c中，在分配struct pid结点时调用。

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;
//从slab中获得struct pid结构
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);//从pid名字空间的位图中分配一个数字PID号。
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); //引用计数。计数为0就释放struct pid结构。
for (type = 0; type < PIDTYPE_MAX; ++type)
INIT_HLIST_HEAD(&pid->tasks[type]);

spin_lock_irq(&pidmap_lock);
for (i = ns->level; i >= 0; i--) {
upid = &pid->numbers[i];
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;
}

*
* attach_pid() must be called with the tasklist_lock write-held.
*/
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]);
}

最初的struct pid是如何建立起来的？

一开始，内核用静态变量初始化了一个struct pid结构给swap(0号进程）使用。还静态初始化了一个pid名字空间。

这是在kernel/pid.ck上定义的。
struct pid_namespace init_pid_ns = {
.kref = {
.refcount       = ATOMIC_INIT(2),
},
.pidmap = {
[ 0 ... PIDMAP_ENTRIES-1] = { ATOMIC_INIT(BITS_PER_PAGE), NULL }
},
.last_pid = 0,
.level = 0,
.child_reaper = &init_task, //每个pid名字空间有一个init进程，用来收养孤儿进程
};
//全局pid_hash中。链接的是struct upid结构，哈希值是由nr(pid)和ns(pid所在名字空间)算出来的.由pid和ns就能得到struct upid结构，再用container_of得到struct pid结构，再从struct pid结构中tasks[]获取task_struct。
static struct hlist_head *pid_hash;
static unsigned int pidhash_shift = 4;
struct pid init_struct_pid = INIT_STRUCT_PID;//一个全局的初始pid结构。也是系统中最初始的PID。其他PID都是由alloc_pid函数从slab中分配的。

下面代码在include/linux/init_task.h中：
extern struct nsproxy init_nsproxy;//名字空间根结点，静态定义
#define INIT_NSPROXY(nsproxy) {                     \
.pid_ns     = **&init_pid_ns,**                 \
.count      = ATOMIC_INIT(1),               \
.uts_ns     = **&init_uts_ns,**                 \
.mnt_ns     = NULL,                     \
INIT_NET_NS(net_ns)                                             \
INIT_IPC_NS(ipc_ns)                     \
}

#define INIT_STRUCT_PID {                       \
.count      = ATOMIC_INIT(1),               \
.tasks      = {                     \
下边三个字段就是初始PID的初始化。可以看到0号进程是自己的组长，会话组长。
**{ .first = &init_task.pids[PIDTYPE_PID].node },       \
{ .first = &init_task.pids[PIDTYPE_PGID].node },    \
{ .first = &init_task.pids[PIDTYPE_SID].node },     \**
},                              \
.rcu        = RCU_HEAD_INIT,                \
.level      = 0,                        \
.numbers    = { {                       \
.nr     = 0,                    \
**.ns       = &init_pid_ns,**               \
.pid_chain  = { .next = NULL, .pprev = NULL },  \
}, }                                \
}

#define INIT_PID_LINK(type)                     \
{                               \
.node = {                       \
.next = NULL,                   \
.pprev = &init_struct_pid.tasks[type].first,    \
},                          \
.pid = &init_struct_pid,                \
}

/*
*  INIT_TASK is used to set up the first task table, touch at
* your own risk!. Base=0, limit=0x1fffff (=2MB)
*/
#define INIT_TASK(tsk)  \初始化第一个进程
{                                   \
.state      = 0,                        \
.stack      = &init_thread_info,                \
.usage      = ATOMIC_INIT(2),               \
.flags      = PF_KTHREAD,                   \
.lock_depth = -1,                       \
.prio       = MAX_PRIO-20,                  \
.static_prio    = MAX_PRIO-20,                  \
.normal_prio    = MAX_PRIO-20,                  \
.policy     = SCHED_NORMAL,                 \
.cpus_allowed   = CPU_MASK_ALL,                 \
.mm     = NULL,                     \
.active_mm  = &init_mm,                 \
.se     = {                     \
.group_node     = LIST_HEAD_INIT(tsk.se.group_node),    \
},                              \
.rt     = {                     \
.run_list   = LIST_HEAD_INIT(tsk.rt.run_list),  \
.time_slice = HZ,                   \
.nr_cpus_allowed = NR_CPUS,             \
},                              \
.tasks      = LIST_HEAD_INIT(tsk.tasks),            \
.pushable_tasks = PLIST_NODE_INIT(tsk.pushable_tasks, MAX_PRIO), \
.ptraced    = LIST_HEAD_INIT(tsk.ptraced),          \
.ptrace_entry   = LIST_HEAD_INIT(tsk.ptrace_entry),     \
.real_parent    = &tsk,                     \
.parent     = &tsk,                     \
.children   = LIST_HEAD_INIT(tsk.children),         \
.sibling    = LIST_HEAD_INIT(tsk.sibling),          \
**.group_leader = &tsk,**                       \
.real_cred  = &init_cred,                   \
.cred       = &init_cred,                   \
.cred_guard_mutex =                     \
__MUTEX_INITIALIZER(tsk.cred_guard_mutex),     \
.comm       = "swapper",                    \
.thread     = INIT_THREAD,                  \
.fs     = &init_fs,                 \
.files      = &init_files,                  \
.signal     = &init_signals,                \
.sighand    = &init_sighand,                \
.nsproxy    = &init_nsproxy,                \
.pending    = {                     \
.list = LIST_HEAD_INIT(tsk.pending.list),       \
.signal = {{0}}},                   \
.blocked    = {{0}},                    \
.alloc_lock = __SPIN_LOCK_UNLOCKED(tsk.alloc_lock),     \
.journal_info   = NULL,                     \
.cpu_timers = INIT_CPU_TIMERS(tsk.cpu_timers),      \
.fs_excl    = ATOMIC_INIT(0),               \
.pi_lock    = __SPIN_LOCK_UNLOCKED(tsk.pi_lock),        \
.timer_slack_ns = 50000, /* 50 usec default slack */        \
**将自己加入struct pid的tasks字段中。**
.pids = {                           \
[PIDTYPE_PID]  = INIT_PID_LINK(PIDTYPE_PID),        \
[PIDTYPE_PGID] = INIT_PID_LINK(PIDTYPE_PGID),       \
[PIDTYPE_SID]  = INIT_PID_LINK(PIDTYPE_SID),        \
},                              \
.dirties = INIT_PROP_LOCAL_SINGLE(dirties),         \
INIT_IDS                            \
INIT_PERF_EVENTS(tsk)                       \
INIT_TRACE_IRQFLAGS                     \
INIT_LOCKDEP                            \
INIT_FTRACE_GRAPH                       \
INIT_TRACE_RECURSION                        \
INIT_TASK_RCU_PREEMPT(tsk)                  \
}

下面代码在arch/x86/kernel/init_task.c中：
/*
* Initial task structure.
*
* All other task structs will be allocated on slabs in fork.c
*/
struct task_struct init_task = INIT_TASK(init_task);
EXPORT_SYMBOL(init_task);