containers: implement subsys->post_clone()
PATCH 1/2 containers: implement subsys->post_clone()
Quoted 1 line
From
aed04d506feac3a71896713a5d5aeded839fdd9eMon Sep 17 00:00:00 2001
From: Serge E. Hallyn <[email protected]>
Date: Tue, 12 Jun 2007 15:06:38 -0400
Subject: [PATCH 1/2] containers: implement subsys->post_clone()
container_clone() in one step creates a new container and moves the current task into it. Since cpusets do not automatically fill in the allowed cpus and mems, and do not allow a task to be attached without these filled in, composing the ns subsystem, which uses container_clone(), and the cpuset subsystem, results in sys_unshare() (and clone(CLONE_NEWNS)) always being denied.
To allow the two subsystems to be meaningfully composed, implement subsystem->post_clone(), called from container_clone() after creating the new container.
Only the cpuset_post_clone() is currently implemented. If any sibling containers have exclusive cpus or mems, then the cpus and mems are not filled in for the new container, meaning that unshare/clone(CLONE_NEWNS) will be denied. However so long as no siblings have exclusive cpus or mems, the new container's cpus and mems are inherited from the parent container.
--- Documentation/containers.txt | 7 +++++++ include/linux/container.h | 1 + kernel/container.c | 7 +++++++ kernel/cpuset.c | 37 +++++++++++++++++++++++++++++++++++++ 4 files changed, 52 insertions(+), 0 deletions(-)
Documentation/containers.txt +7 -0
@@ -514,6 +514,13 @@ include/linux/container.h for details). Note that although this method can return an error code, the error code is currently not always handled well. +void post_clone(struct container_subsys *ss, struct container *cont) + +Called at the end of container_clone() to do any paramater +initialization which might be required before a task could attach. For +example in cpusets, no task may attach before 'cpus' and 'mems' are set +up. + void bind(struct container_subsys *ss, struct container *root) LL=callback_mutex
include/linux/container.h +1 -0
@@ -213,6 +213,7 @@ struct container_subsys {void (*exit)(struct container_subsys *ss,struct task_struct *task);int (*populate)(struct container_subsys *ss,struct container *cont); +void (*post_clone)(struct container_subsys *ss,struct container *cont);void (*bind)(struct container_subsys *ss,struct container *root);int subsys_id;int active;
kernel/container.c +7 -0
@@ -2315,6 +2315,7 @@ int container_clone(struct task_struct *tsk, struct container_subsys *subsys)struct inode *inode;struct css_group *cg;struct containerfs_root *root; +struct container_subsys *ss;/* We shouldn't be called by an unregistered subsystem */ BUG_ON (!subsys->active);
@@ -2394,6 +2395,12 @@ int container_clone(struct task_struct *tsk, struct container_subsys *subsys) goto again; } +/* do any required auto-setup */ +for_each_subsys (root, ss) { +if (ss->post_clone) + ss->post_clone (ss, child); + } +/* All seems fine. Finish by moving the task into the new container */ ret =attach_task (child, tsk);mutex_unlock (&container_mutex);
kernel/cpuset.c +37 -0
@@ -1190,6 +1190,42 @@ int cpuset_populate(struct container_subsys *ss, struct container *cont) }/* +* post_clone() is called at the end of container_clone(). +* 'container' was just created automatically as a result of +* a container_clone(), and the current task is about to +* be moved into 'container'. +* +* Currently we refuse to set up the container - thereby +* refusing the task to be entered, and as a result refusing +* the sys_unshare() or clone() which initiated it - if any +* sibling cpusets have exclusive cpus or mem. +* +* If this becomes a problem for some users who wish to +* allow that scenario, then cpuset_post_clone() could be +* changed to grant parent->cpus_allowed-sibling_cpus_exclusive +* (and likewise for mems) to the new container. +*/ +void cpuset_post_clone (struct container_subsys *ss, +struct container *container) +{ +struct container *parent, *child; +struct cpuset *cs, *parent_cs; + + parent = container->parent; +list_for_each_entry (child, &parent->children, sibling) { + cs =container_cs (child); +if (is_mem_exclusive (cs) ||is_cpu_exclusive (cs)) +return ; + } + cs =container_cs (container); + parent_cs =container_cs (parent); + + cs->mems_allowed = parent_cs->mems_allowed; + cs->cpus_allowed = parent_cs->cpus_allowed; +return ; +} + +/* * cpuset_create - create a cpuset * parent: cpuset that will be parent of the new cpuset. * name: name of the new cpuset. Will be strcpy'ed.
@@ -1249,6 +1285,7 @@ struct container_subsys cpuset_subsys = { .can_attach = cpuset_can_attach, .attach = cpuset_attach, .populate = cpuset_populate, + .post_clone = cpuset_post_clone, .subsys_id = cpuset_subsys_id, .early_init = 1, };
Signature · 1 line
1.5.1.1.GIT
PATCH 2/2 containers: implement namespace tracking subsystem (v3)
Quoted 1 line
From
3efbf21565c69fe4dd76b9fcf073f6f9954aa1faMon Sep 17 00:00:00 2001
From: Serge E. Hallyn <[email protected]>
Date: Tue, 5 Jun 2007 10:25:05 -0400
Subject: [PATCH 2/2] containers: implement namespace tracking subsystem (v3)
When a task enters a new namespace via a clone() or unshare(), a new container is created and the task moves into it.
This version names containers which are automatically created using container_clone() as "node_<pid>" where pid is the pid of the unsharing or cloned process. (Thanks Pavel for the idea) This is safe because if the process unshares again, it will create
/containers/(...)/node_<pid>/node_<pid>
The only possibilities (AFAICT) for a -EEXIST on unshare are
1. pid wraparound
2. a process fails an unshare, then tries again.
Case 1 is unlikely enough that I ignore it (at least for now). In case 2, the node_<pid> will be empty and can be rmdir'ed to make the subsequent unshare() succeed.
Changelog:
Name cloned containers as "node_<pid>".
(no idea where to start versioning, calling this v3 "at random")
--- include/linux/container_subsys.h | 6 ++ include/linux/nsproxy.h | 7 +++ init/Kconfig | 9 ++++ kernel/Makefile | 1 + kernel/container.c | 23 +++++---- kernel/ns_container.c | 99 ++++++++++++++++++++++++++++++++++++++ kernel/nsproxy.c | 16 ++++++ 7 files changed, 152 insertions(+), 9 deletions(-) create mode 100644 kernel/ns_container.c
include/linux/container_subsys.h +6 -0
@@ -24,3 +24,9 @@ SUBSYS(debug)#endif /* */ + +#ifdef CONFIG_CONTAINER_NS +SUBSYS(ns) +#endif + +/* */
include/linux/nsproxy.h +7 -0
@@ -54,4 +54,11 @@ static inline void exit_task_namespaces(struct task_struct *p) put_nsproxy(ns); } } + +#ifdef CONFIG_CONTAINER_NS +int ns_container_clone (struct task_struct *tsk); +#else +static inline int ns_container_clone (struct task_struct *tsk) {return 0 ; } +#endif +#endif
init/Kconfig +9 -0
@@ -355,6 +355,15 @@ config CONTAINER_CPUACCT Provides a simple Resource Controller for monitoring the total CPU consumed by the tasks in a container +config CONTAINER_NS + bool "Namespace container subsystem" + select CONTAINERS + help + Provides a simple namespace container subsystem to + provide hierarchical naming of sets of namespaces, + for instance virtual servers and checkpoint/restart + jobs. + config PROC_PID_CPUSET bool "Include legacy /proc/<pid>/cpuset file" depends on CPUSETS
kernel/Makefile +1 -0
@@ -40,6 +40,7 @@ obj-$(CONFIG_CONTAINERS) += container.o obj-$(CONFIG_CONTAINER_DEBUG) += container_debug.o obj-$(CONFIG_CPUSETS) += cpuset.o obj-$(CONFIG_CONTAINER_CPUACCT) += cpu_acct.o +obj-$(CONFIG_CONTAINER_NS) += ns_container.o obj-$(CONFIG_IKCONFIG) += configs.o obj-$(CONFIG_STOP_MACHINE) += stop_machine.o obj-$(CONFIG_AUDIT) += audit.o auditfilter.o
kernel/container.c +14 -9
@@ -2295,12 +2295,6 @@ void container_exit(struct task_struct *tsk, int run_callbacks)put_css_group_taskexit (cg); } -static atomic_t namecnt; -static void get_unused_name (char *buf) -{ -sprintf (buf,"node%d" ,atomic_inc_return (&namecnt)); -} -/** * container_clone - duplicate the current container in the hierarchy * that the given subsystem is attached to, and move this task into
@@ -2310,7 +2304,7 @@ int container_clone(struct task_struct *tsk, struct container_subsys *subsys) {struct dentry *dentry;int ret =0 ; -char nodename[32 ]; +char nodename[MAX_CONTAINER_TYPE_NAMELEN ];struct container *parent, *child;struct inode *inode;struct css_group *cg;
@@ -2334,6 +2328,9 @@ int container_clone(struct task_struct *tsk, struct container_subsys *subsys) } cg = tsk->containers; parent =task_container (tsk, subsys->subsys_id); + +snprintf (nodename,MAX_CONTAINER_TYPE_NAMELEN ,"node_%d" , tsk->pid); +/* Pin the hierarchy */ atomic_inc (&parent->root->sb->s_active);
@@ -2342,7 +2339,6 @@ int container_clone(struct task_struct *tsk, struct container_subsys *subsys)mutex_unlock (&container_mutex);/* Now do the VFS work to create a container */ -get_unused_name (nodename); inode = parent->dentry->d_inode;/* Hold the parent directory mutex across this operation to
@@ -2415,8 +2411,14 @@ int container_clone(struct task_struct *tsk, struct container_subsys *subsys)return ret; } -/* See if "cont" is a descendant of the current task's container in +/* +* See if "cont" is a descendant of the current task's container in * the appropriate hierarchy +* +* If we are sending in dummytop, then presumably we are creating +* the top container in the subsystem. +* +* Called only by the ns (nsproxy) container. */ int container_is_descendant (const struct container *cont) {
@@ -2424,6 +2426,9 @@ int container_is_descendant(const struct container *cont)struct container *target;int subsys_id; +if (cont == dummytop) +return 1 ; +get_first_subsys (cont,NULL , &subsys_id); target =task_container (current, subsys_id);while (cont != target && cont!= cont->top_container)
kernel/ns_container.c new file +99 -0
99 lines not on this page · raw message
kernel/nsproxy.c +16 -0
@@ -124,7 +124,14 @@ int copy_namespaces(int flags, struct task_struct *tsk) goto out; } + err =ns_container_clone (tsk); +if (err) { +put_nsproxy (new_ns); + goto out; + } + tsk->nsproxy = new_ns; + out:put_nsproxy (old_ns);return err;
@@ -177,6 +184,15 @@ int unshare_nsproxy_namespaces(unsigned long unshare_flags,if (IS_ERR (*new_nsp)) { err =PTR_ERR (*new_nsp);put_nsproxy (old_ns); + goto out; + } + + err =ns_container_clone (current); +if (err) { +put_nsproxy (*new_nsp); +put_nsproxy (old_ns); } + +out:return err; }
Signature · 1 line
1.5.1.1.GIT
Re: [PATCH 2/2] containers: implement namespace tracking subsystem (v3)
Quoted 6 lines · On Wed, 13 Jun 2007 18:01:25 -0500 "Serge E. Hallyn" <[email protected]> wrote:
kernel/nsproxy.c +2
-0@@ -177,6 +184,15 @@ int unshare_nsproxy_namespaces(unsigned long unshare_flags,if (IS_ERR (*new_nsp)) { err =PTR_ERR (*new_nsp);put_nsproxy (old_ns); + goto out; + }
kernel/nsproxy.c int unshare_nsproxy_namespaces(unsigned long unshare_flags, · line 198
Quoted 10 lines
kernel/nsproxy.c +7
-0+ + err =ns_container_clone (current); +if (err) { +put_nsproxy (*new_nsp); +put_nsproxy (old_ns); } + +out:return err; }
I had to fix a reject here: the put_nsproxy(old_ns) has disappeared from this code.
end result:
int unshare_nsproxy_namespaces(unsigned long unshare_flags,
struct nsproxy **new_nsp, struct fs_struct *new_fs)
{
int err = 0;
if (!(unshare_flags & (CLONE_NEWNS | CLONE_NEWUTS | CLONE_NEWIPC |
CLONE_NEWUSER)))
return 0;
if (!capable(CAP_SYS_ADMIN))
return -EPERM;
*new_nsp = create_new_namespaces(unshare_flags, current,
new_fs ? new_fs : current->fs);
if (IS_ERR(*new_nsp))
err = PTR_ERR(*new_nsp);
goto out;
}
err = ns_container_clone(current);
if (err)
put_nsproxy(*new_nsp);out:
return err; }
Re: [PATCH 2/2] containers: implement namespace tracking subsystem (v3)
Quoted 14 lines · Andrew Morton
Quoted 11 lines · On Wed, 13 Jun 2007 18:01:25 -0500 "Serge E. Hallyn" <[email protected]> wrote:
kernel/nsproxy.c +7
-0@@ -177,6 +184,15 @@ int unshare_nsproxy_namespaces(unsigned long unshare_flags,if (IS_ERR (*new_nsp)) { err =PTR_ERR (*new_nsp);put_nsproxy (old_ns); + goto out; + } + + err =ns_container_clone (current); +if (err) { +put_nsproxy (*new_nsp); +put_nsproxy (old_ns);
Quoted 8 lines
kernel/nsproxy.c int unshare_nsproxy_namespaces(unsigned long unshare_flags, · line 198
Quoted 5 lines
kernel/nsproxy.c +2
-0} + +out:return err; }I had to fix a reject here: the
put_nsproxy(old_ns)has disappeared from this code.
Thanks Andrew, end result looks good.
-serge
Quoted 28 lines
end result:
int unshare_nsproxy_namespaces(unsigned long
unshare_flags,
struct nsproxy **new_nsp, structfs_struct*new_fs){ int err = 0; if (!(unshare_flags & (CLONE_NEWNS | CLONE_NEWUTS | CLONE_NEWIPC | CLONE_NEWUSER))) return 0; if (!capable(CAP_SYS_ADMIN)) return -EPERM; *new_nsp = create_new_namespaces(unshare_flags, current, new_fs ? new_fs : current->fs); if (IS_ERR(*new_nsp)) err = PTR_ERR(*new_nsp); goto out; } err = ns_container_clone(current); if (err) put_nsproxy(*new_nsp);out:
return err; }
Quoted 6 lines
Only the
cpuset_post_clone()is currently implemented. If any sibling containers have exclusive cpus or mems, then the cpus and mems are not filled in for the new container, meaning that unshare/clone(CLONE_NEWNS) will be denied. However so long as no siblings have exclusive cpus or mems, the new container's cpus and mems are inherited from the parent container.
I'm ok with this part.
Signature · 3 lines
I won't rest till it's the best ...
Programmer, Linux Scalability
Paul Jackson <[email protected]> 1.925.600.0401