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

posted @ 2021-08-23 18:27  大辉哥  阅读(407)  评论(0编辑  收藏  举报