Linux Namespaces機制——實現

轉自：http://www.cnblogs.com/lisperl/archive/2012/05/03/2480573.html

因爲Linux內核提供了PID，IPC，NS等多個Namespace，一個進程可能屬於多個Namespace。爲了task_struct的精簡，內核引入了struct nsproxy來統一管理進程所屬的Namespace，在task_struct中只需存一個指向struct nsproxy的指針就好了。struct nsproxy定義以下：

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;

struct net       *net_ns;

};

從定義能夠看出，nsproxy存儲了一組指向各個類型Namespace的指針，爲進程訪問各個Namespace起了一個代理的做用。因爲可能有多個進程所在的Namespace徹底同樣，nsproxy能夠在進程間共享，count字段負責記錄該結構的引用數。

系統預約義了一個init_nsproxy，用做默認的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 = &init_pid_ns,

#ifdef CONFIG_NET

.net_ns = &init_net,

#endif

};

其中除了mnt_ns外均指向系統默認的Namespace。

內核定義了一組函數來管理nsproxy：

task_nsproxy用於從task_struct指針在RCU保護下得到其中的nsproxy指針。

put_nsproxy用於減小一個nsproxy的引用數。

get_nsproxy用於增長一個nsproxy的引用數。

create_nsproxy用於分配一個新的nsproxy結構。

下面咱們來看系統在clone時的處理。系統調用clone是經過sys_clone實現的，而sys_clone又是經過內核函數do_fork實現的，而do_fork大部分工做又是在copy_process中作的。在copy_process中，有這樣的代碼：

if ((retval = copy_namespaces(clone_flags, p)))

goto bad_fork_cleanup_mm;

這裏咱們回過頭去看copy_namespaces的代碼

int copy_namespaces(unsigned long flags, struct task_struct *tsk)

{

struct nsproxy *old_ns = tsk->nsproxy;

struct nsproxy *new_ns;

int err = 0;

 

if (!old_ns)

return 0;

 

get_nsproxy(old_ns);

 

if (!(flags & (CLONE_NEWNS | CLONE_NEWUTS | CLONE_NEWIPC |

CLONE_NEWPID | CLONE_NEWNET)))

return 0;

 

if (!capable(CAP_SYS_ADMIN)) {

err = -EPERM;

goto out;

}

 

/*

 * CLONE_NEWIPC must detach from the undolist: after switching

 * to a new ipc namespace, the semaphore arrays from the old

 * namespace are unreachable.  In clone parlance, CLONE_SYSVSEM

 * means share undolist with parent, so we must forbid using

 * it along with CLONE_NEWIPC.

 */

if ((flags & CLONE_NEWIPC) && (flags & CLONE_SYSVSEM)) {

err = -EINVAL;

goto out;

}

 

new_ns = create_new_namespaces(flags, tsk, tsk->fs);

if (IS_ERR(new_ns)) {

err = PTR_ERR(new_ns);

goto out;

}

 

tsk->nsproxy = new_ns;

 

out:

put_nsproxy(old_ns);

return err;

}

該函數首先檢查flags，若是沒有指定任何一個須要新建Namespace的flag，直接返回0。不然，作相應的權能檢查，而後調用create_new_namespaces爲進程建立新的Namespace。

咱們再來看create_new_namespaces的代碼

static struct nsproxy *create_new_namespaces(unsigned long flags,

struct task_struct *tsk, struct fs_struct *new_fs)

{

struct nsproxy *new_nsp;

int err;

 

new_nsp = create_nsproxy();

if (!new_nsp)

return ERR_PTR(-ENOMEM);

 

new_nsp->mnt_ns = copy_mnt_ns(flags, tsk->nsproxy->mnt_ns, new_fs);

if (IS_ERR(new_nsp->mnt_ns)) {

err = PTR_ERR(new_nsp->mnt_ns);

goto out_ns;

}

 

new_nsp->uts_ns = copy_utsname(flags, tsk->nsproxy->uts_ns);

if (IS_ERR(new_nsp->uts_ns)) {

err = PTR_ERR(new_nsp->uts_ns);

goto out_uts;

}

 

new_nsp->ipc_ns = copy_ipcs(flags, tsk->nsproxy->ipc_ns);

if (IS_ERR(new_nsp->ipc_ns)) {

err = PTR_ERR(new_nsp->ipc_ns);

goto out_ipc;

}

 

new_nsp->pid_ns = copy_pid_ns(flags, task_active_pid_ns(tsk));

if (IS_ERR(new_nsp->pid_ns)) {

err = PTR_ERR(new_nsp->pid_ns);

goto out_pid;

}

 

new_nsp->net_ns = copy_net_ns(flags, tsk->nsproxy->net_ns);

if (IS_ERR(new_nsp->net_ns)) {

err = PTR_ERR(new_nsp->net_ns);

goto out_net;

}

 

return new_nsp;

 

out_net:

if (new_nsp->pid_ns)

put_pid_ns(new_nsp->pid_ns);

out_pid:

if (new_nsp->ipc_ns)

put_ipc_ns(new_nsp->ipc_ns);

out_ipc:

if (new_nsp->uts_ns)

put_uts_ns(new_nsp->uts_ns);

out_uts:

if (new_nsp->mnt_ns)

put_mnt_ns(new_nsp->mnt_ns);

out_ns:

kmem_cache_free(nsproxy_cachep, new_nsp);

return ERR_PTR(err);

}
該函數首先爲進程分配一個新的nsproxy（由於有新的Namespace建立），而後調用各個Namespace相關的函數來爲進程一一建立新的Namespace（若是flags指定了的話）。具體的各個Namespace相關的建立函數比較複雜，與各自實現相關，就不在這裏分析了。

咱們再回到copy_process中，有如下代碼：

if (pid != &init_struct_pid) {

retval = -ENOMEM;

pid = alloc_pid(p->nsproxy->pid_ns);

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;

}

}

因爲從do_fork中調用copy_process時，pid參數是NULL，因此這裏確定知足第一個if條件。在if內，首先爲進程在其所在的Namespace分配pid，而後判斷clone時是否set了CLONE_NEWPID，若是設定了就作進一步的處理。這兩個函數都是pid Namespace相關的代碼，這裏就不去分析了。

而後有如下代碼：

if (current->nsproxy != p->nsproxy) {

retval = ns_cgroup_clone(p, pid);

if (retval)

goto bad_fork_free_pid;

}

因爲咱們分析的是設定了clone相關flags的狀況，那這個if條件確定知足。在if裏面，調用了ns_cgroup_clone，即爲不一樣nsproxy新建了一個cgroup（關於cgroups的分析能夠參加本博客前面的文章：http://www.cnblogs.com/lisperl/archive/2012/04/26/2471776.html）。這裏就和以前關於cgroups ns子系統的分析關聯起來了，內核這裏其實是利用cgroups ns子系統對進程作了一個自動分類，相同nsproxy（即全部Namespace都相同的進程）的進程在一個cgroup，一旦經過clone建立新的Namespace，就會在當前cgroup下建立一個新的cgroup。這樣以來，經過cgroup文件系統，在掛載ns 子系統的目錄下，咱們就能夠清楚地看出Namespace的層次關係。

你們看到這裏是否是會有疑問，使用clone相應flags建立新的Namespace是否是必需要cgroups ns子系統的支持？做者能夠負責任地告訴你：不須要。

在nsproxy.h中有如下代碼：

 

#ifdef CONFIG_CGROUP_NS
int ns_cgroup_clone(struct task_struct *tsk, struct pid *pid);
#else
static inline int ns_cgroup_clone(struct task_struct *tsk, struct pid *pid)
{
return 0;
}
#endif

即在沒有cgroups的狀況下，ns_cgroup_clone實現是不一樣的。

 

  做者曰：這裏只是對Linux Namespaces機制的實現作了一個大致的上分析，具體到各個Namespace的實現並無去講，由於很是複雜，尤爲是Network Namespace。