namaspace之pid namespace

认识Namespace

namespace 是 Linux 内核用来隔离内核资源的方式。通过 namespace 可以让一些进程只能看到与自己相关的一部分资源，而另外一些进程也只能看到与它们自己相关的资源，这两拨进程根本就感觉不到对方的存在。linux 内核提供的 namespace 技术为 docker 等容器技术的出现和发展提供了基础条件。

Linux 现有的namespace 有7种：

namespace	宏	隔离内容
Cgroup	CLONE_NEWCGROUP	Cgroup root directory
IPC	CLONE_NEWIPC	System V IPC, POSIX消息队列
Network	CLONE_NEWNET	网络设备、栈、端口等
Mount	CLONE_NEWNS	挂载点
PID	CLONE_NEWPID	进程ID
User	CLONE_NEWUSER	用户和组ID
UTS	CLONE_NEWUTS	主机名和NIS域名

其中Cgroup namespace在4.6的内核中才实现。本文只介绍pid namespace。文章写的比较繁琐，还请大家耐心看到后面( ^_^ ) ~~~~

Namespace操作函数

和namespace相关的函数只有三个，如下所示：

一、clone: 创建一个新的进程并把他放到新的namespace中。

int clone(int (*child_func)(void *), void *child_stack, int flags, void *arg); 

其中：flags用于指定一个或者多个上面的CLONE_NEW*宏定义（当然也可以包含跟namespace无关的flags，多个flags 用|进行分隔），这样就会创建一个或多个新的不同类型的namespace，并把新创建的子进程加入新创建的这些namespace中。

二、setns: 将当前进程加入到已有的namespace中

int setns(int fd, int nstype); 

其中：

• fd：指向/proc/[pid]/ns/目录里相应namespace对应的文件，表示要加入哪个namespace
• nstype：指定namespace的类型（上面的任意一个CLONE_NEW*），具体分为两种情况：1. 如果当前进程不能根据fd得到它的类型，如fd由其他进程创建，并通过UNIX domain socket传给当前进程，那么就需要通过nstype来指定fd指向的namespace的类型。2. 如果进程能根据fd得到namespace类型，比如这个fd是由当前进程打开的，那么nstype设置为0即可。

三、unshare: 使当前进程退出指定类型的namespace，并加入到新创建的namespace（相当于创建并加入新的namespace）。

int unshare(int flags); 

其中：flags用于指定一个或者多个上面的CLONE_NEW*宏定义（当然也可以包含跟namespace无关的flags，多个flags 用|进行分隔），这样就会创建一个或多个新的不同类型的namespace，并把新创建的子进程加入新创建的这些namespace中。 clone和unshare的区别

clone和unshare的功能都是创建并加入新的namespace， 他们的区别是：

• unshare是使当前进程加入新的namespace。
• clone是创建一个新的子进程，然后让子进程加入新的namespace，而当前进程保持不变。

pid namespace有什么用？

PID Namespace对进程PID重新标号，即不同的Namespace下的进程可以有同一个PID。

内核为所有的PID Namespace维护了一个树状结构，最顶层的是系统初始化创建的，被称为Root Namespace，由它创建的新的PID Namespace成为它的Child namespace，原先的PID Namespace成为新创建的Parent Namespace，这种情况下不同的PID Namespace形成一个等级体系：父节点可以看到子节点中的进程，可以通过信号对子节点的进程产生影响，反过来子节点无法看到父节点PID Namespace里面的进程。下面用一个图描述容器、进程pid、pid namespace关系：

PID namesapce 对容器类应用特别重要， 可以实现容器内进程的暂停/恢复等功能，还可以支持容器在跨主机的迁移前后保持内部进程的 PID 不发生变化。

pid namespace 特性

1、进程所属的 PID namespace 在它创建的时候就确定了，不能更改，所以调用 unshare 和 nsenter 等命令后，原进程还是属于老的 PID namespace，新 fork 出来的进程才属于新的 PID namespace；

2、PID namespace 可以嵌套；

3、PID namespace 中的 init 进程。当一个进程的父进程退出后，该进程就变成了孤儿进程。孤儿进程会被当前 PID namespace 中 PID 为 1 的进程接管，而不是被最外层的系统级别的 init 进程接管。

---

下面从kernel源码中了解下pid namespace的原理和用法。所有kernel源码均来自linux 4.18.0。

核心数据结构

1、内核使用struct pid_namespace 结构体描述进程号命名空间：

//include/linux/pid_namespace.h
struct pid_namespace {
    struct kref kref;
    struct idr idr;
    struct rcu_head rcu;
    unsigned int pid_allocated;
    struct task_struct *child_reaper;
    struct kmem_cache *pid_cachep;
    unsigned int level;
    struct pid_namespace *parent;
#ifdef CONFIG_PROC_FS
    struct vfsmount *proc_mnt;
    struct dentry *proc_self;
    struct dentry *proc_thread_self;
#endif
#ifdef CONFIG_BSD_PROCESS_ACCT
    struct fs_pin *bacct;
#endif
    struct user_namespace *user_ns;
    struct ucounts *ucounts;
    struct work_struct proc_work;
    kgid_t pid_gid;
    int hide_pid;
    int reboot;        /* group exit code if this pidns was rebooted */
    struct ns_common ns;
} __randomize_layout;

2、内核将所有的namespace封装成struct nsproxy ，struct pid_namespace就在该结构体中：

//include/linux/nsproxy.h
struct nsproxy {
    atomic_t count;
    struct uts_namespace *uts_ns;
    struct ipc_namespace *ipc_ns;
    struct mnt_namespace *mnt_ns;
    struct pid_namespace *pid_ns_for_children;
    struct net              *net_ns;
    struct cgroup_namespace *cgroup_ns;
};

3、命名空间是进程资源隔离技术，自然是要放在进程描述符中，下面截取struct task_struct部分：

struct task_struct {
    ... ...
        struct fs_struct *fs;
    struct files_struct *files;
    struct nsproxy *nsproxy;
    ... ...
};

至此内核中 pid namespace组织形式有了初步认识，下面介绍下pid namespace的初始化和相关内核API。

调用过程分析

【1】系统 init进程的pid namespace

每一个进程都有自己的namespace（struct nsproxy），可以看做是这个进程自己的“地盘”。进程默认都是共享init进程的namespace，即系统“默认”的根命名空间（目录树、pid等）。pid_namespace按层次组织成一棵树，init进程pid namespace是树的根，对应全局变量 init_pid_ns：

注意，创建进程时，从进程所属的pid_namespace到init_pid_ns 都会分配进程号！

init进程的pid_namespace是在内核初始化阶段创建的。在x86体系结构上，kernel将init进程namespace数据放在了“.data”段上，下面是截取的部分源码：

• 上面提到的 init_pid_ns 统一放在init进程全局变量init_nsproxy中：

struct nsproxy init_nsproxy = {
    .count                        = ATOMIC_INIT(1),
    .uts_ns                        = &init_uts_ns,
#if defined(CONFIG_POSIX_MQUEUE) || defined(CONFIG_SYSVIPC)
    .ipc_ns                        = &init_ipc_ns,
#endif
    .mnt_ns                        = NULL,
    .pid_ns_for_children        = &init_pid_ns, //init进程的pid_namespace
#ifdef CONFIG_NET
    .net_ns                        = &init_net,
#endif
#ifdef CONFIG_CGROUPS
    .cgroup_ns                = &init_cgroup_ns,
#endif
};

init进程的进程描述符是静态定义的，init_nsproxy就放在其中：

struct task_struct
… …
    .fs                = &init_fs,
    .files                = &init_files,
    .signal                = &init_signals,
    .sighand        = &init_sighand,
    .nsproxy        = &init_nsproxy, //命名空间代理
… …
}

通过链接脚本，可以看到init进程静态定义的进程描述符放在内核数据段：

//include/asm-generic/vmlinux.lds.h
#define INIT_TASK_DATA(align)                                                \
    . = ALIGN(align);                                                \
    __start_init_task = .;                                                \
    init_thread_union = .;                                                \
    init_stack = .;                                                        \
    KEEP(*(.data..init_task))                                        \
    KEEP(*(.data..init_thread_info))                                \
    . = __start_init_task + THREAD_SIZE;                                \
__end_init_task = .;

//arch/x86/kernel/vmlinux.lds.S
SECTIONS
{
    … …
    /* init_task */
    INIT_TASK_DATA(THREAD_SIZE)
    … …
}

【2】子进程的pid_namespace

进程创建时函数调用栈如下（包含pid namespace创建）：

sys_fork / sys_vfork / sys_clone / kernel_thread
└→ _do_fork
      └→ copy_process
          └→ copy_namespaces
               └→ create_new_namespaces
                        └→ copy_pid_ns

在内核中进程创建核心函数是copy_process()，新建pid namespace的核心函数是copy_pid_ns()。下面依次分析。

• 首先在进程创建时，会判断是否需要新建pid namespace。copy_process()函数调用copy_namespaces() 函数处理子进程namespace相关，下面截取该函数部分：

int copy_namespaces(unsigned long flags, struct task_struct *tsk)
{
    struct nsproxy *old_ns = tsk->nsproxy;
    struct user_namespace *user_ns = task_cred_xxx(tsk, user_ns);
    struct nsproxy *new_ns;

    if (likely(!(flags & (CLONE_NEWNS | CLONE_NEWUTS | CLONE_NEWIPC |
                  CLONE_NEWPID | CLONE_NEWNET |
                  CLONE_NEWCGROUP)))) {
        get_nsproxy(old_ns); //如果flags中没有CONE_NEW相关新建namespace标记，则继承父进程的namespace
        return 0;
    }
        ... ...
    new_ns = create_new_namespaces(flags, tsk, user_ns, tsk->fs); //否则创建新的namespace
        ... ...
}

这里“get_nsproxy(old_ns) ”比较简单，增加父进程namespace引用计数，大部分子进程都是继承init进程的namespace。下面重点看下如何创建新的namespace。create_new_namespaces() 函数中调用copy_pid_ns() 来新建pid namespace，他的核心是create_pid_namespace() ，源码节选：

static struct pid_namespace *create_pid_namespace(struct user_namespace *user_ns,
    struct pid_namespace *parent_pid_ns)
{
    struct pid_namespace *ns;
    unsigned int level = parent_pid_ns->level + 1;  //新创建的pid_namespace在树中新一层
        … …
    ns = kmem_cache_zalloc(pid_ns_cachep, GFP_KERNEL);
    if (ns == NULL)
        goto out_dec;
        … …
    ns->pid_cachep = create_pid_cachep(level); //struct pid结构体高速缓存
    ns->ns.ops = &pidns_operations;

    kref_init(&ns->kref);
    ns->level = level;
    ns->parent = get_pid_ns(parent_pid_ns);    //父pid_namespace
    ns->user_ns = get_user_ns(user_ns);
    ns->ucounts = ucounts;
    ns->pid_allocated = PIDNS_ADDING;    //初始化新pid_namespace pid计数
    INIT_WORK(&ns->proc_work, proc_cleanup_work);
        … …
}

【3】创建子进程pid

如何用标识一个进程呢？对于进程id，虽然用户空间使用一个正整数来表示各种IDs，但是对于内核，我们需要使用“pid namespace，ID number”这样的二元组来表示。因为同样的进程在不同的 PID namespace 中拥有不同的 PID。linux内核使用struct pid结构体来标识进程：

struct pid
{
    atomic_t count;
    unsigned int level;   //该进程所属的pid_ns的level，也就表示了这个pid对象在多少个pid namespace中可见。
    /* lists of tasks that use this pid */
    struct hlist_head tasks[PIDTYPE_MAX]; //使用该pid结构体的进程描述符集合
    struct rcu_head rcu;
    struct upid numbers[1];  //存储每层的pid信息的变成数组，长度就是上面的level
};
struct upid {
    int nr; //该层pid ns 的PID值
    struct pid_namespace *ns; //该层pid ns结构体地址
};

关于标识进程的各个ID详解（pid/tid/tgid/sid等），感兴趣的可以参考《Linux系统如何标识进程?》一文。

在进程创建核心函数copy_process中，通过alloc_pid 函数为子进程申请一个“struct pid”：

//copy_process()
if (pid != &init_struct_pid) { //pid指针是函数入参，普通进程创建时调用的__do_fork中该参数为NULL
        pid = alloc_pid(p->nsproxy->pid_ns_for_children);
        if (IS_ERR(pid)) {
            retval = PTR_ERR(pid);
            goto bad_fork_cleanup_thread;
        }
    }

pid指针是函数入参，普通进程创建时调用的__do_fork函数中，pid参数为NULL，因此一般进程都会调用“alloc_pid”创建新的struct pid：

struct pid *alloc_pid(struct pid_namespace *ns)  //参数是新进程pid ns，返回值是申请的pid结构体
{
    struct pid *pid;
    enum pid_type type;
    int i, nr;
    struct pid_namespace *tmp;
    struct upid *upid;
    int retval = -ENOMEM;

    pid = kmem_cache_alloc(ns->pid_cachep, GFP_KERNEL);  //pid_ns 初始化时赋值了pid缓存
    if (!pid)
        return ERR_PTR(retval);

    tmp = ns;
    pid->level = ns->level;  //pid成员level记录新进程pid_ns的level，即进程ns的编号

    for (i = ns->level; i >= 0; i--) {    //遍历所有父pid_ns，pid结构体内需要记录每层pid_ns分配的pid值
        int pid_min = 1;     //如果进程的pid_ns是新创建的，则pid值从1开始
… …
        nr = idr_alloc_cyclic(&tmp->idr, NULL, pid_min,
                  pid_max, GFP_ATOMIC);
        spin_unlock_irq(&pidmap_lock);
        idr_preload_end();
… …
        pid->numbers[i].nr = nr;    //在pid结构体中记录每层pid_ns分配的pid值
        pid->numbers[i].ns = tmp;    //记录每层pid_ns分配同时，记录pid值对应进程的pid_ns地址
        tmp = tmp->parent;
    }
… …

    upid = pid->numbers + ns->level;    //更新每层pid_ns的pid已使用值：pid_allocated
… …
    for ( ; upid >= pid->numbers; --upid) {
        /* Make the PID visible to find_pid_ns. */
        idr_replace(&upid->ns->idr, pid, upid->nr);
        upid->ns->pid_allocated++;  //更新这层pid_ns的pid已使用值，即直接加一即可
    }
    spin_unlock_irq(&pidmap_lock);

    return pid;
… …
}

【4】保存进程ID信息

在解析完子进程pid创建后，下面看看如何保存到进程描述符（task_struct）中。再回到进程创建copy_process函数中，有两处和保存进程ID信息相关：

//in copy_process func：
    p->pid = pid_nr(pid);   //获取global pid_ns中的pid，即第0层
        … …
        init_task_pid(p, PIDTYPE_PID, pid);   //将struct pid 结构地址保存到进程描述符中

• 首先task_struct->pid中存的是global pid namespace中的PID value，因为对于内核来说，它只需要看全局的pid namespace即可（init进程），里面包含系统全局进程的global PID。
• 第二个函数init_task_pid 和相关结构体如下：

static inline void
init_task_pid(struct task_struct *task, enum pid_type type, struct pid *pid)
{
     task->pids[type].pid = pid;
}

struct task_struct
{
        … …
    struct pid_link        pids[PIDTYPE_MAX];
        … …
}
enum pid_type
{
    PIDTYPE_PID,
    PIDTYPE_PGID,
    PIDTYPE_SID,
    PIDTYPE_MAX,
    /* only valid to __task_pid_nr_ns() */
    __PIDTYPE_TGID
};
struct pid_link
{
    struct hlist_node node;
    struct pid *pid;
};

我们知道在linux中并不区分进程和线程，都是用task_struct来抽象，只不过支持多线程的进程是由一组task_struct来抽象。struct pid 结构可能被多个进程共享（比如表示pgid时），为了既能方便从task struct快速找到对应的struct pid，又能方便从struct pid能够遍历所有使用该pid的task，内核设计了 struct pid_link 来保存各个ID对应的struct pid 结构地址。

【5】获取进程PID value

linux内核提供三个标准API，用于获取进程PID value：

1. pid_nr()： 获取全局pid_ns pid value，即第0 level，来自init namespace

static inline pid_t pid_nr(struct pid *pid)
{
    pid_t nr = 0;
    if (pid)
        nr = pid->numbers[0].nr;
    return nr;
}

2. pid_vnr() ：获取当前pid_ns pid value，即进程当前pid namespace

pid_t pid_vnr(struct pid *pid)
{
    return pid_nr_ns(pid, task_active_pid_ns(current));
}
EXPORT_SYMBOL_GPL(pid_vnr);

3. pid_nr_ns() ：获取指定ns 中的pid value

pid_t pid_nr_ns(struct pid *pid, struct pid_namespace *ns)
{
    struct upid *upid;
    pid_t nr = 0;

    if (pid && ns->level <= pid->level) {
        upid = &pid->numbers[ns->level];
        if (upid->ns == ns)
            nr = upid->nr;
    }
    return nr;
}
EXPORT_SYMBOL_GPL(pid_nr_ns);

• 内核空间系统管理只需要关注“默认”的根命名空间中的PID value即可，因此调用pid_nr在task_struct->pid中缓存的PID value ，称为global PID；
• 用户空间运用namespace进程资源隔离，因此用户空间获取进程PID 的系统调用getpid需要关注pid namespace。相关系统调用源码如下：

SYSCALL_DEFINE0(getpid)
{
    return task_tgid_vnr(current);
}
static inline pid_t task_tgid_vnr(struct task_struct *tsk)
{
    return __task_pid_nr_ns(tsk, __PIDTYPE_TGID, NULL);
}
pid_t __task_pid_nr_ns(struct task_struct *task, enum pid_type type,
    struct pid_namespace *ns)
{
    if (!ns)
        ns = task_active_pid_ns(current);
        … …
    nr = pid_nr_ns(rcu_dereference(task->pids[type].pid), ns);
    }
    rcu_read_unlock();

    return nr;
}

因此用户空间获取的是进程当前pid namespace里的pid value，称为virtual PID。

【6】根据pid获取pid_namespace

函数ns_of_pid 用于根据pid获取pid_namespace：

static inline struct pid_namespace *ns_of_pid(struct pid *pid)
{
    struct pid_namespace *ns = NULL;
    if (pid)
        ns = pid->numbers[pid->level].ns;
    return ns;
}

docker namespace原理：https://blog.csdn.net/zhonglinzhang/article/details/64441263