cgroup: support checking of subsystem dependencies

PATCH In review Li Zefan 5 participants 11 messages Jun 18, 2008 – Jul 1, 2008

Subsystems (2)

Documentation cgroup

lore

Share & tools

lore

Li Zefan

author

2008-06-18 08:01 UTC #0 lore raw

PATCH 1/1 cgroup: support checking of subsystem dependencies

This allows one subsystem to require that it only be mounted when some other subsystems are also present in the proposed hierarchy.

For example if subsystem foo depends on bar, the following will fail:

 # mount -t cgroup -ofoo xxx /dev/cgroup

You should mount with both subsystems:

 # mount -t cgroup -ofoo,bar xxx /dev/cgroup

Signed-off-by Li Zefan <[email protected]>

---
 Documentation/cgroups.txt |    6 ++++++
 include/linux/cgroup.h    |    2 ++
 kernel/cgroup.c           |   30 ++++++++++++++++++++++++++++++
 3 files changed, 38 insertions(+), 0 deletions(-)

Documentation/cgroups.txt +6 -0

index 824fc02..8252f5b 100644
@@ -530,6 +530,12 @@ and root cgroup. Currently this will only involve movement between
 the default hierarchy (which never has sub-cgroups) and a hierarchy
 that is being created/destroyed (and hence has no sub-cgroups).
 
+int subsys_depend(struct cgroup_subsys *ss, unsigned long subsys_bits)
+
+Called when a cgroup subsystem wants to check if some other subsystems
+are also present in the proposed hierarchy. If this method returns error,
+the mount of the cgroup filesystem will fail.
+
 4. Questions
 ============

include/linux/cgroup.h +2 -0

index e155aa7..fc99ba4 100644
@@ -305,6 +305,8 @@ struct cgroup_subsys {
 			struct cgroup *cgrp);
 	void (*post_clone)(struct cgroup_subsys *ss, struct cgroup *cgrp);
 	void (*bind)(struct cgroup_subsys *ss, struct cgroup *root);
+	int (*subsys_depend)(struct cgroup_subsys *ss,
+			      unsigned long subsys_bits);
 	/*
 	 * This routine is called with the task_lock of mm->owner held
 	 */

kernel/cgroup.c +30 -0

index 15ac0e1..a4c8671 100644
@@ -837,6 +837,25 @@ static int parse_cgroupfs_options(char *data,
 	return 0;
 }
 
+static int check_subsys_dependency(unsigned long subsys_bits)
+{
+	int i;
+	int ret;
+	struct cgroup_subsys *ss;
+
+	for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
+		ss = subsys[i];
+
+		if (test_bit(i, &subsys_bits) && ss->subsys_depend) {
+			ret = ss->subsys_depend(ss, subsys_bits);
+			if (ret)
+				return ret;
+		}
+	}
+
+	return 0;
+}
+
 static int cgroup_remount(struct super_block *sb, int *flags, char *data)
 {
 	int ret = 0;

@@ -852,6 +871,10 @@ static int cgroup_remount(struct super_block *sb, int *flags, char *data)
 	if (ret)
 		goto out_unlock;
 
+	ret = check_subsys_dependency(opts.subsys_bits);
+	if (ret)
+		goto out_unlock;
+
 	/* Don't allow flags to change at remount */
 	if (opts.flags != root->flags) {
 		ret = -EINVAL;

@@ -972,6 +995,13 @@ static int cgroup_get_sb(struct file_system_type *fs_type,
 		return ret;
 	}
 
+	ret = check_subsys_dependency(opts.subsys_bits);
+	if (ret) {
+		if (opts.release_agent)
+			kfree(opts.release_agent);
+		return ret;
+	}
+
 	root = kzalloc(sizeof(*root), GFP_KERNEL);
 	if (!root) {
 		if (opts.release_agent)

Signature · 1 line

1.5.4.rc3

Paul Menage

2008-06-18 21:13 UTC #1 lore raw

Quoted 77 lines · Li Zefan

This allows one subsystem to require that it only be mounted when some other subsystems are also present in the proposed hierarchy.

For example if subsystem foo depends on bar, the following will fail:

 # mount -t cgroup -ofoo xxx /dev/cgroup

You should mount with both subsystems:

 # mount -t cgroup -ofoo,bar xxx /dev/cgroup

Signed-off-by Li Zefan <[email protected]>

---
 Documentation/cgroups.txt |    6 ++++++
 include/linux/cgroup.h    |    2 ++
 kernel/cgroup.c           |   30 ++++++++++++++++++++++++++++++
 3 files changed, 38 insertions(+), 0 deletions(-)

Documentation/cgroups.txt +6 -0

index 824fc02..8252f5b 100644
@@ -530,6 +530,12 @@ and root cgroup. Currently this will only involve movement between
 the default hierarchy (which never has sub-cgroups) and a hierarchy
 that is being created/destroyed (and hence has no sub-cgroups).
 
+int subsys_depend(struct cgroup_subsys *ss, unsigned long subsys_bits)
+
+Called when a cgroup subsystem wants to check if some other subsystems
+are also present in the proposed hierarchy. If this method returns error,
+the mount of the cgroup filesystem will fail.
+
 4. Questions
 ============

include/linux/cgroup.h +2 -0

index e155aa7..fc99ba4 100644
@@ -305,6 +305,8 @@ struct cgroup_subsys {
                       struct cgroup *cgrp);
       void (*post_clone)(struct cgroup_subsys *ss, struct cgroup *cgrp);
       void (*bind)(struct cgroup_subsys *ss, struct cgroup *root);
+       int (*subsys_depend)(struct cgroup_subsys *ss,
+                             unsigned long subsys_bits);
       /*
        * This routine is called with the task_lock of mm->owner held
        */

kernel/cgroup.c +19 -0

index 15ac0e1..a4c8671 100644
@@ -837,6 +837,25 @@ static int parse_cgroupfs_options(char *data,
       return 0;
 }
 
+static int check_subsys_dependency(unsigned long subsys_bits)
+{
+       int i;
+       int ret;
+       struct cgroup_subsys *ss;
+
+       for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
+               ss = subsys[i];
+
+               if (test_bit(i, &subsys_bits) && ss->subsys_depend) {
+                       ret = ss->subsys_depend(ss, subsys_bits);
+                       if (ret)
+                               return ret;
+               }
+       }
+
+       return 0;
+}
+
 static int cgroup_remount(struct super_block *sb, int *flags, char *data)
 {
       int ret = 0;

kernel/cgroup.c static int cgroup_remount(struct super_block *sb, int *flags, char *data) · line 877

Quoted 7 lines

kernel/cgroup.c +4 -0

@@ -852,6 +871,10 @@ static int cgroup_remount(struct super_block *sb, int *flags, char *data)
       if (ret)
               goto out_unlock;
 
+       ret = check_subsys_dependency(opts.subsys_bits);
+       if (ret)
+               goto out_unlock;
+

Can we just call this from one place, in parse_cgroupfs_options() ?

Paul

Li Zefan

author

2008-06-19 00:43 UTC #2 lore raw

Quoted 7 lines

Quoted 7 lines
static int cgroup_remount(struct super_block *sb, int *flags, char *data)
 {
       int ret = 0;
kernel/cgroup.c +0 -0
@@ -852,6 +871,10 @@ static int cgroup_remount(struct super_block *sb, int *flags, char *data)
       if (ret)
               goto out_unlock;
 

Quoted 7 lines

kernel/cgroup.c static int cgroup_remount(struct super_block *sb, int *flags, char *data) · line 877
Quoted 4 lines
kernel/cgroup.c +4 -0
+       ret = check_subsys_dependency(opts.subsys_bits);
+       if (ret)
+               goto out_unlock;
+
Can we just call this from one place, in parse_cgroupfs_options() ?

I think yes we can. I'll revise it.

Li Zefan

author

2008-06-19 01:51 UTC #3 lore raw

PATCH 1/1 cgroup: support checking of subsystem dependencies (v2)

In reply to Paul Menage

This allows one subsystem to require that it only be mounted when some other subsystems are also present in the proposed hierarchy.

For example if subsystem foo depends on bar, the following will fail:

 # mount -t cgroup -ofoo xxx /dev/cgroup

You should mount with both subsystems:

 # mount -t cgroup -ofoo,bar xxx /dev/cgroup

foo may implement the subsys_depend() callback this way:

static int foo_cgroup_subsys_depend(struct cgroup_subsys *ss,
unsigned long subsys_bits)

{
	if (!test_bit(bar_cgroup_subsys_id, &subsys_bits))
		return -EINVAL;
	return 0;
}

Changelog:
- call check_subsys_depend() in parse_cgroupfs_options(), but not in mount and remount code.

Signed-off-by Li Zefan <[email protected]>

---
 Documentation/cgroups.txt |    6 ++++++
 include/linux/cgroup.h    |    2 ++
 kernel/cgroup.c           |   21 ++++++++++++++++++++-
 3 files changed, 28 insertions(+), 1 deletions(-)

Documentation/cgroups.txt +6 -0

index 824fc02..8252f5b 100644
@@ -530,6 +530,12 @@ and root cgroup. Currently this will only involve movement between
 the default hierarchy (which never has sub-cgroups) and a hierarchy
 that is being created/destroyed (and hence has no sub-cgroups).
 
+int subsys_depend(struct cgroup_subsys *ss, unsigned long subsys_bits)
+
+Called when a cgroup subsystem wants to check if some other subsystems
+are also present in the proposed hierarchy. If this method returns error,
+the mount of the cgroup filesystem will fail.
+
 4. Questions
 ============

include/linux/cgroup.h +2 -0

index e155aa7..fc99ba4 100644
@@ -305,6 +305,8 @@ struct cgroup_subsys {
 			struct cgroup *cgrp);
 	void (*post_clone)(struct cgroup_subsys *ss, struct cgroup *cgrp);
 	void (*bind)(struct cgroup_subsys *ss, struct cgroup *root);
+	int (*subsys_depend)(struct cgroup_subsys *ss,
+			      unsigned long subsys_bits);
 	/*
 	 * This routine is called with the task_lock of mm->owner held
 	 */

kernel/cgroup.c +20 -1

index 15ac0e1..18e8132 100644
@@ -774,6 +774,25 @@ static int cgroup_show_options(struct seq_file *seq, struct vfsmount *vfs)
 	return 0;
 }
 
+static int check_subsys_dependency(unsigned long subsys_bits)
+{
+	int i;
+	int ret;
+	struct cgroup_subsys *ss;
+
+	for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
+		ss = subsys[i];
+
+		if (test_bit(i, &subsys_bits) && ss->subsys_depend) {
+			ret = ss->subsys_depend(ss, subsys_bits);
+			if (ret)
+				return ret;
+		}
+	}
+
+	return 0;
+}
+
 struct cgroup_sb_opts {
 	unsigned long subsys_bits;
 	unsigned long flags;

@@ -834,7 +853,7 @@ static int parse_cgroupfs_options(char *data,
 	if (!opts->subsys_bits)
 		return -EINVAL;
 
-	return 0;
+	return check_subsys_dependency(opts->subsys_bits);
 }
 
 static int cgroup_remount(struct super_block *sb, int *flags, char *data)

Signature · 1 line

1.5.4.rc3

Andrew Morton

2008-07-01 07:51 UTC #5 lore raw

Re: [PATCH] cgroup: support checking of subsystem dependencies (v2)

In reply to Li Zefan

Quoted 35 lines · On Thu, 19 Jun 2008 09:51:36 +0800 Li Zefan…

This allows one subsystem to require that it only be mounted when some other subsystems are also present in the proposed hierarchy.
For example if subsystem foo depends on bar, the following will fail:
 # mount -t cgroup -ofoo xxx /dev/cgroup
You should mount with both subsystems:
 # mount -t cgroup -ofoo,bar xxx /dev/cgroup
foo may implement the subsys_depend() callback this way:
static int foo_cgroup_subsys_depend(struct cgroup_subsys *ss,
unsigned long subsys_bits)
{
	if (!test_bit(bar_cgroup_subsys_id, &subsys_bits))
		return -EINVAL;
	return 0;
}
Changelog:
- call check_subsys_depend() in parse_cgroupfs_options(), but not in mount and remount code.
Signed-off-by Li Zefan <[email protected]>
---
 Documentation/cgroups.txt |    6 ++++++
 include/linux/cgroup.h    |    2 ++
 kernel/cgroup.c           |   21 ++++++++++++++++++++-
 3 files changed, 28 insertions(+), 1 deletions(-)
Documentation/cgroups.txt +0 -0
index 824fc02..8252f5b 100644

Documentation/cgroups.txt and root cgroup. Currently this will only involve movement between · line 537

Quoted 8 lines

Documentation/cgroups.txt +5 -0

@@ -530,6 +530,12 @@ and root cgroup. Currently this will only involve movement between
 the default hierarchy (which never has sub-cgroups) and a hierarchy
 that is being created/destroyed (and hence has no sub-cgroups).
 
+int subsys_depend(struct cgroup_subsys *ss, unsigned long subsys_bits)
+
+Called when a cgroup subsystem wants to check if some other subsystems
+are also present in the proposed hierarchy. If this method returns error,
+the mount of the cgroup filesystem will fail.

OK, but the name subsys_depend is quite poor.

check_subsys_dependency is better. But it still has the failing that the reader cannot determine the sense of the function's return value from its name. Does it return true on success, or false?

A good name would be something like subsys_dependencies_ok(). Then code such as

	if (subsys_dependencies_ok(...))
		go_wild();
	else
		bad_hair_day();

makes more sense.

Quoted 21 lines

Documentation/cgroups.txt +0 -0

 4. Questions
 ============

include/linux/cgroup.h +2 -0

index e155aa7..fc99ba4 100644
@@ -305,6 +305,8 @@ struct cgroup_subsys {
 			struct cgroup *cgrp);
 	void (*post_clone)(struct cgroup_subsys *ss, struct cgroup *cgrp);
 	void (*bind)(struct cgroup_subsys *ss, struct cgroup *root);
+	int (*subsys_depend)(struct cgroup_subsys *ss,
+			      unsigned long subsys_bits);
 	/*
 	 * This routine is called with the task_lock of mm->owner held
 	 */

kernel/cgroup.c +0 -0

index 15ac0e1..18e8132 100644

kernel/cgroup.c static int cgroup_show_options(struct seq_file *seq, struct vfsmount *vfs) · line 777

Quoted 4 lines

kernel/cgroup.c +1 -0

@@ -774,6 +774,25 @@ static int cgroup_show_options(struct seq_file *seq, struct vfsmount *vfs)
 	return 0;
 }
 
+static int check_subsys_dependency(unsigned long subsys_bits)

Would be nice to have a little comment explaining this function's role in the world. It should document the meaning of the return values.

Perhaps it could return bool. That depends upon a well-chosen name, and upon the thus-far-undocumented return-value meaning.

Quoted 23 lines

kernel/cgroup.c +17 -0

+{
+	int i;
+	int ret;
+	struct cgroup_subsys *ss;
+
+	for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
+		ss = subsys[i];
+
+		if (test_bit(i, &subsys_bits) && ss->subsys_depend) {
+			ret = ss->subsys_depend(ss, subsys_bits);
+			if (ret)
+				return ret;
+		}
+	}
+
+	return 0;
+}
 
 
 struct cgroup_sb_opts {
 	unsigned long subsys_bits;
 	unsigned long flags;

kernel/cgroup.c static int parse_cgroupfs_options(char *data, · line 857

Quoted 6 lines

kernel/cgroup.c +1 -1

@@ -834,7 +853,7 @@ static int parse_cgroupfs_options(char *data,
 	if (!opts->subsys_bits)
 		return -EINVAL;
 
-	return 0;
+	return check_subsys_dependency(opts->subsys_bits);
 }

The whole patch doesn't do anything. Perhaps there's another patch in the pipeline somewhere which adds one or more ->subsys_depend implementations, but I cannot find it. If so, I'd have expected this patch to be titled [1/N].

Li Zefan

author

2008-07-01 08:43 UTC #6 lore raw

Re: [PATCH] cgroup: support checking of subsystem dependencies (v2)

Quoted 8 lines

Documentation/cgroups.txt and root cgroup. Currently this will only involve movement between · line 537
Quoted 5 lines
Documentation/cgroups.txt +5 -0
+int subsys_depend(struct cgroup_subsys *ss, unsigned long subsys_bits)
+
+Called when a cgroup subsystem wants to check if some other subsystems
+are also present in the proposed hierarchy. If this method returns error,
+the mount of the cgroup filesystem will fail.
OK, but the name subsys_depend is quite poor.

Quoted 4 lines

check_subsys_dependency is better. But it still has the failing that the reader cannot determine the sense of the function's return value from its name. Does it return true on success, or false?

Other callbacks return -errno on failure and 0 on success, so I make this new callback behave the same, and the errno will be returned by the mount command.

But it seems true/false is more reasonable, then if it returns false, mount can return EINVAL.

I'll document the return value.

Quoted 10 lines

A good name would be something like subsys_dependencies_ok(). Then code such as
	if (subsys_dependencies_ok(...))
		go_wild();
	else
		bad_hair_day();
makes more sense.

Seems better.

Quoted 25 lines

4. Questions
============

include/linux/cgroup.h +2 -0

index e155aa7..fc99ba4 100644
@@ -305,6 +305,8 @@ struct cgroup_subsys {
 			struct cgroup *cgrp);
 	void (*post_clone)(struct cgroup_subsys *ss, struct cgroup *cgrp);
 	void (*bind)(struct cgroup_subsys *ss, struct cgroup *root);
+	int (*subsys_depend)(struct cgroup_subsys *ss,
+			      unsigned long subsys_bits);
 	/*
 	 * This routine is called with the task_lock of mm->owner held
 	 */

kernel/cgroup.c +0 -0

index 15ac0e1..18e8132 100644
@@ -774,6 +774,25 @@ static int cgroup_show_options(struct seq_file *seq, struct vfsmount *vfs)
 	return 0;
 }

Quoted 8 lines

kernel/cgroup.c static int cgroup_show_options(struct seq_file *seq, struct vfsmount *vfs) · line 777
Quoted 1 line
kernel/cgroup.c +1 -0
+static int check_subsys_dependency(unsigned long subsys_bits)
Would be nice to have a little comment explaining this function's role in the world. It should document the meaning of the return values.
Perhaps it could return bool. That depends upon a well-chosen name, and upon the thus-far-undocumented return-value meaning.

will fix.

Quoted 26 lines

kernel/cgroup.c +17 -0

+{
+	int i;
+	int ret;
+	struct cgroup_subsys *ss;
+
+	for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
+		ss = subsys[i];
+
+		if (test_bit(i, &subsys_bits) && ss->subsys_depend) {
+			ret = ss->subsys_depend(ss, subsys_bits);
+			if (ret)
+				return ret;
+		}
+	}
+
+	return 0;
+}
 
 
 struct cgroup_sb_opts {
 	unsigned long subsys_bits;
 	unsigned long flags;

@@ -834,7 +853,7 @@ static int parse_cgroupfs_options(char *data,
 	if (!opts->subsys_bits)
 		return -EINVAL;

Quoted 9 lines

kernel/cgroup.c static int parse_cgroupfs_options(char *data, · line 857
Quoted 3 lines
kernel/cgroup.c +1 -1
-	return 0;
+	return check_subsys_dependency(opts->subsys_bits);
 }
The whole patch doesn't do anything. Perhaps there's another patch in the pipeline somewhere which adds one or more ->subsys_depend implementations, but I cannot find it. If so, I'd have expected this patch to be titled [1/N].

Yes, the patch does nothing actually. Daisuke Nishimura-san's original swap controller needed to be mounted with memory controller, but the newer version makes it an addon to memory controller, so it currently doesn't need the feature this patch provides.

Or I can keep this patch until some new cgroup subsystem needs it ?

Andrew Morton

2008-07-01 08:54 UTC #7 lore raw

Re: [PATCH] cgroup: support checking of subsystem dependencies (v2)

Quoted 6 lines · On Tue, 01 Jul 2008 16:43:30 +0800 Li Zefan <[email protected]> wrote:

Quoted 5 lines
The whole patch doesn't do anything. Perhaps there's another patch in the pipeline somewhere which adds one or more ->subsys_depend implementations, but I cannot find it. If so, I'd have expected this patch to be titled [1/N].

Quoted 6 lines

Yes, the patch does nothing actually. Daisuke Nishimura-san's original swap controller needed to be mounted with memory controller, but the newer version makes it an addon to memory controller, so it currently doesn't need the feature this patch provides.
Or I can keep this patch until some new cgroup subsystem needs it ?

That would be better. Once something needs this patch, we do

[patch 1/n]: cgroup: support checking of subsystem dependencies [patch 2/n]: <use it>

KAMEZAWA Hiroyuki

2008-06-19 00:12 UTC #8 lore raw

In reply to Li Zefan

Quoted 9 lines · On Wed, 18 Jun 2008 16:01:49 +0800 Li Zefan <[email protected]> wrote:

This allows one subsystem to require that it only be mounted when some other subsystems are also present in the proposed hierarchy.
For example if subsystem foo depends on bar, the following will fail:
 # mount -t cgroup -ofoo xxx /dev/cgroup
You should mount with both subsystems:
 # mount -t cgroup -ofoo,bar xxx /dev/cgroup

I'm just curious. May I ask "Is there such cgroup subsystem now ?"

Thanks,
-Kame

Quoted 97 lines

Signed-off-by Li Zefan <[email protected]>

---
 Documentation/cgroups.txt |    6 ++++++
 include/linux/cgroup.h    |    2 ++
 kernel/cgroup.c           |   30 ++++++++++++++++++++++++++++++
 3 files changed, 38 insertions(+), 0 deletions(-)

Documentation/cgroups.txt +6 -0

index 824fc02..8252f5b 100644
@@ -530,6 +530,12 @@ and root cgroup. Currently this will only involve movement between
 the default hierarchy (which never has sub-cgroups) and a hierarchy
 that is being created/destroyed (and hence has no sub-cgroups).
 
+int subsys_depend(struct cgroup_subsys *ss, unsigned long subsys_bits)
+
+Called when a cgroup subsystem wants to check if some other subsystems
+are also present in the proposed hierarchy. If this method returns error,
+the mount of the cgroup filesystem will fail.
+
 4. Questions
 ============

include/linux/cgroup.h +2 -0

index e155aa7..fc99ba4 100644
@@ -305,6 +305,8 @@ struct cgroup_subsys {
 			struct cgroup *cgrp);
 	void (*post_clone)(struct cgroup_subsys *ss, struct cgroup *cgrp);
 	void (*bind)(struct cgroup_subsys *ss, struct cgroup *root);
+	int (*subsys_depend)(struct cgroup_subsys *ss,
+			      unsigned long subsys_bits);
 	/*
 	 * This routine is called with the task_lock of mm->owner held
 	 */

kernel/cgroup.c +30 -0

index 15ac0e1..a4c8671 100644
@@ -837,6 +837,25 @@ static int parse_cgroupfs_options(char *data,
 	return 0;
 }
 
+static int check_subsys_dependency(unsigned long subsys_bits)
+{
+	int i;
+	int ret;
+	struct cgroup_subsys *ss;
+
+	for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
+		ss = subsys[i];
+
+		if (test_bit(i, &subsys_bits) && ss->subsys_depend) {
+			ret = ss->subsys_depend(ss, subsys_bits);
+			if (ret)
+				return ret;
+		}
+	}
+
+	return 0;
+}
+
 static int cgroup_remount(struct super_block *sb, int *flags, char *data)
 {
 	int ret = 0;

@@ -852,6 +871,10 @@ static int cgroup_remount(struct super_block *sb, int *flags, char *data)
 	if (ret)
 		goto out_unlock;
 
+	ret = check_subsys_dependency(opts.subsys_bits);
+	if (ret)
+		goto out_unlock;
+
 	/* Don't allow flags to change at remount */
 	if (opts.flags != root->flags) {
 		ret = -EINVAL;

@@ -972,6 +995,13 @@ static int cgroup_get_sb(struct file_system_type *fs_type,
 		return ret;
 	}
 
+	ret = check_subsys_dependency(opts.subsys_bits);
+	if (ret) {
+		if (opts.release_agent)
+			kfree(opts.release_agent);
+		return ret;
+	}
+
 	root = kzalloc(sizeof(*root), GFP_KERNEL);
 	if (!root) {
 		if (opts.release_agent)

Signature · 1 line

1.5.4.rc3

Li Zefan

author

2008-06-19 00:40 UTC #9 lore raw

Quoted 6 lines · KAMEZAWA Hiroyuki

Quoted 3 lines · On Wed, 18 Jun 2008 16:01:49 +0800 Li Zefan <[email protected]> wrote:
This allows one subsystem to require that it only be mounted when some other subsystems are also present in the proposed hierarchy.

Quoted 8 lines

Quoted 6 lines
For example if subsystem foo depends on bar, the following will fail:
 # mount -t cgroup -ofoo xxx /dev/cgroup
You should mount with both subsystems:
 # mount -t cgroup -ofoo,bar xxx /dev/cgroup
I'm just curious. May I ask "Is there such cgroup subsystem now ?"

Currently no, but people who are developing or wants to develop new subsystems may find this useful, for example Daisuke Nishimura-san's swap controller.

Daisuke Nishimura

2008-06-19 02:30 UTC #10 lore raw

Quoted 10 lines · Li Zefan

Quoted 9 lines · KAMEZAWA Hiroyuki
Quoted 6 lines · On Wed, 18 Jun 2008 16:01:49 +0800 Li Zefan <[email protected]> wrote:
This allows one subsystem to require that it only be mounted when some other subsystems are also present in the proposed hierarchy.
For example if subsystem foo depends on bar, the following will fail:
 # mount -t cgroup -ofoo xxx /dev/cgroup

Quoted 9 lines

Quoted 5 lines
Quoted 3 lines
You should mount with both subsystems:
 # mount -t cgroup -ofoo,bar xxx /dev/cgroup
I'm just curious. May I ask "Is there such cgroup subsystem now ?"
Currently no, but people who are developing or wants to develop new subsystems may find this useful, for example Daisuke Nishimura-san's swap controller.

My current version is implemented as addon to memory controller, so it can be used by just mounting memory controller :)

But anyway, this feature might be used in future by some subsystems.

Thanks,
Daisuke Nishimura.