Skip to contentSkip to conversation

Have sane default values for cpusets

PATCH/RFC Dhaval Giani 8 participants 31 messages May 12, 2010 – May 14, 2010 4 messages not in the archive

lore
Share & tools
lore

A message that is not in the archive (sent off-list or not yet received): [email protected]

A message that is not in the archive (sent off-list or not yet received): [email protected]

A message that is not in the archive (sent off-list or not yet received): [email protected]

#3 lore raw
Quoted 9 lines · Dhaval Giani
Quoted 5 lines · Peter Zijlstra
Quoted 1 line · Dhaval Giani

Where cpusets goes wrong is to have a *no* default values.

It has a default, empty is still a valid value.

Well, it is still not sane. And in the part you snipped, I did mention,

Quoted 8 lines
Quoted 2 lines
Quoted 2 lines

do we enforce a policy to have sane defaults
for subsystems if they prevent attaching "regular" tasks by default.

And to add to it, a sane default can be defined as one, where a task can be attached to a cgroup on creation without changing any other parameter.

Dhaval

By keeping the insane policy, we force everyone to properly setup to sane defaults. By automatically inheriting the defaults, we would be introducing the possibility of a lazy programmer forgetting to setup the proper defaults for their application which may need different values than the inherited settings. This would lead to ensuing chaos eventually.

James

#4 lore raw

[Please do *NOT* drop the cc list]

Quoted 17 lines · James Kosin
Quoted 16 lines · Dhaval Giani
Quoted 5 lines · Peter Zijlstra
Quoted 1 line · Dhaval Giani

Where cpusets goes wrong is to have a *no* default values.

It has a default, empty is still a valid value.

Well, it is still not sane. And in the part you snipped, I did mention,

Quoted 2 lines
Quoted 2 lines

do we enforce a policy to have sane defaults
for subsystems if they prevent attaching "regular" tasks by default.

And to add to it, a sane default can be defined as one, where a task can be attached to a cgroup on creation without changing any other parameter.

Quoted 7 lines
Quoted 1 line

Dhaval

By keeping the insane policy, we force everyone to properly setup to sane defaults.  By automatically inheriting the defaults, we would be introducing the possibility of a lazy programmer forgetting to setup the proper defaults for their application which may need different values than the inherited settings.  This would lead to ensuing chaos eventually.

Nope. Not really. What you are saying is that an application programmer who wants to just use memory cgroups should also care about cpusets and just about countless other cgroup subsystems that can exist. A lazy programmer not setting up a sane value for what he cares about will see abnormal execution of his application and be able to fix it.

You are talking about moving the burden of setup to the people who should be least concerned about it.

Dhaval

#5 lore raw
Quoted 4 lines · Dhaval Giani

What you are saying is that an application
programmer who wants to just use memory cgroups should also care about cpusets and just about countless other cgroup subsystems that can exist.

That's exactly what he says if he mounts them together.

#6 lore raw
Quoted 8 lines · Peter Zijlstra
Quoted 4 lines · Dhaval Giani

What you are saying is that an application
programmer who wants to just use memory cgroups should also care about cpusets and just about countless other cgroup subsystems that can exist.

That's exactly what he says if he mounts them together.

No. That's not under his control.

Dhaval

#7 lore raw
In reply to Peter Zijlstra
Quoted 7 lines · Peter Zijlstra
Quoted 4 lines · Dhaval Giani

What you are saying is that an application
programmer who wants to just use memory cgroups should also care about cpusets and just about countless other cgroup subsystems that can exist.

That's exactly what he says if he mounts them together.

No, the programmer does not mount anything. Programmer writes application which wants to create a subgroup. System admin is the one who decides what is mounted how. And the programmer (=me) needs a way how to reliably create a subgroup, without knowing details about all controllers. E.g. 'blkio' controller is quite new one, old applications do now know anything about it, yet according to your idea, the application *must* provide sane defaults to it.

Jan

A message that is not in the archive (sent off-list or not yet received): [email protected]

#9 lore raw
Quoted 24 lines · James Kosin

On 5/12/2010 10:40 AM, Jan Safranek wrote:

On 05/12/2010 04:20 PM, Peter Zijlstra wrote:

On Wed, 2010-05-12 at 16:13 +0200, Dhaval Giani wrote:

What you are saying is that an application
programmer who wants to just use memory cgroups should also care about cpusets and just about countless other cgroup subsystems that can exist.

That's exactly what he says if he mounts them together.

No, the programmer does not mount anything. Programmer writes application which wants to create a subgroup. System admin is the one who decides what is mounted how. And the programmer (=me) needs a way how to reliably create a subgroup, without knowing details about all controllers. E.g. 'blkio' controller is quite new one, old applications do now know anything about it, yet according to your idea, the application *must* provide sane defaults to it.

Jan

Quoted 8 lines

Jan,

I think sane defaults should be enforced only if the application actively uses the device.  Your right in that you don't want to have to guess as to which devices are mounted as long as you don't touch the devices that aren't mounted everything should be okay and work for the specific device or mount you are working with  (which by the way you need to know!!!)....

I seem to get the impression that there is a miscommunication here. We are talking about the cgroups feature here (more details are available at http://www.mjmwired.net/kernel/Documentation/cgroups.txt ). We really are not talking about devices, but about specific cgroup subsystems which can be mounted together, and are not under the control of the programmer.

Quoted 3 lines

PS: Providing a set of defaults on creation may lead to a security problem... just an afterthought.

Which is why you have *sane* defaults.

Dhaval

#10 lore raw
Quoted 10 lines · Dhaval Giani

I seem to get the impression that there is a miscommunication here. We are talking about the cgroups feature here (more details are available at http://www.mjmwired.net/kernel/Documentation/cgroups.txt ). We really are not talking about devices, but about specific cgroup subsystems which can be mounted together, and are not under the control of the programmer.

Quoted 3 lines

Dhaval

Thanks for clearing that up.
It looks like they are not under the control of the programmer on purpose. It is not outlined in the description of how to use this feature. The tasks have to be added separately by an administrator that is operating the system to tune performance and to provide resources where most needed.

#11 lore raw
Quoted 6 lines · James Kosin

Thanks for clearing that up.
It looks like they are not under the control of the programmer on purpose. It is not outlined in the description of how to use this feature. The tasks have to be added separately by an administrator that is operating the system to tune performance and to provide resources where most needed.

Depending on the type of system, they may or may not be under the control of the programmer. In an embedded environment, the programmer is the administrator and generally has control over how the groups are set up. On a more generic time-sharing system it's likely that the individual programmer won't have control over the groups.

Something I haven't tried is whether or not it's possible to set ownership/permissions on subtrees within the cgroup hierarchy to allow unprivileged users/groups to control their own tasks (basically letting them prioritize their own jobs without being able to affect anything else). Does anyone know if this sort of thing is possible?

Chris

#12 lore raw
Quoted 5 lines · Chris Friesen

Something I haven't tried is whether or not it's possible to set ownership/permissions on subtrees within the cgroup hierarchy to allow unprivileged users/groups to control their own tasks (basically letting them prioritize their own jobs without being able to affect anything else). Does anyone know if this sort of thing is possible?

Yep, it is.

Signature · 2 lines
	Three Cheers,
	Balbir
#13 lore raw
In reply to Peter Zijlstra
Quoted 8 lines · Peter Zijlstra
Quoted 4 lines · Dhaval Giani

What you are saying is that an application
programmer who wants to just use memory cgroups should also care about cpusets and just about countless other cgroup subsystems that can exist.

That's exactly what he says if he mounts them together.

Well, this is not realistic.

See Dhaval's patch on the background of systemd
(http://0pointer.de/blog/projects/systemd.html). When a service is started in systemd, we create a cgroup for it, when it ends, we remove it. While systemd does that to keep track of processes this has the nice side effect that all services are properly (and without races) sorted into different groups: if you start apache, then you get it into its own group, if you started cups, you get your own group for that -- without further configuration. Now, while the main reason to do that is for keeping track of processes this is also useful to actually enforce limits and suchlike on those groups and hence services. An admin can choose to enforce limits on the groups systemd creates
for him, because most likely the grouping systemd does along service lines is the one that matters the most.

I am not interested to make systemd aware of each and every controller that exists and will exist in the future and encode specific inheritance rules for them. That is simply not possible, we'd have to add a lot of logic to systemd I simply don't want to maintain there, and I'd have to constantly play catch-up with every controller that is added to the kernel. However, if I don't have that in systemd, as it stands now and an admin tells systemd to duplicate its groups tree in the cpuset hierarchy, then systemd would fail to work. And that is not acceptable.

So, just for once, see this from the perspective of the people using your code: if admins want to piggybick resource limiting onto the normal systemd cgroup tree, then you make that impossible by having weird inheritance rules that systemd would first have to learn. (And I am sorry, but I refuse to teach those rules to systemd, anyway)

What I am arguing here is basically that it is really important to allow userspace code to create groups in hierarchies where controllers are active that the userspace code does not know.

Also, it's completely stupid anyway to ask userspace code to implement inheritance rules for each cgroup controller, if that algorithm could just as well with minimal work be implemented on the kernel side for free, and then allows userspace to simply rely on "mkdir" to result in a working subgroup.

Or let me say this with other words: if an "mkdir" is not enough to create a working sub-cgroup then libcgroup would have to learn the necessary inheritance rules and how to copy group params from the parent to the child -- and that for each and every controller that exists and will exist. If a new controller is added you'd have to patch libcgroup and the kernel and make sure they always stay in sync. And that's just crappy design, if you ask me, and doesn't scale.

Lennart

#14 lore raw
Quoted 4 lines · Lennart Poettering

See Dhaval's patch on the background of systemd
(http://0pointer.de/blog/projects/systemd.html). When a service is started in systemd, we create a cgroup for it, when it ends, we remove it.

I seriously hope that's optional, because I for one would really hate a system that does that. I still mostly build kernels with only cpuset in and really don't want anybody but me creating groups in there.

#15 lore raw
Quoted 10 lines · Peter Zijlstra
Quoted 4 lines · Lennart Poettering

See Dhaval's patch on the background of systemd
(http://0pointer.de/blog/projects/systemd.html). When a service is started in systemd, we create a cgroup for it, when it ends, we remove it.

I seriously hope that's optional, because I for one would really hate a system that does that. I still mostly build kernels with only cpuset in and really don't want anybody but me creating groups in there.

By default systemd will create its groups in the "debug" hierarchy, (at least for now, in the long run i'd like to see "noop" hierarchy or so, that doesn't sound so temporary), since that controller is not useful for anything but keeping track of processes. So it shouldn't bother you at all.

Lennart

Signature · 3 lines
Lennart Poettering                        Red Hat, Inc.
lennart [at] poettering [dot] net
http://0pointer.net/lennart/           GnuPG 0x1A015CC4
#16 lore raw
Quoted 3 lines · Lennart Poettering

By default systemd will create its groups in the "debug" hierarchy, (at least for now, in the long run i'd like to see "noop" hierarchy or so, that doesn't sound so temporary), since that controller is not useful

If you just want to track processes, mount a (named) hierarchy with no attached subsystems.

Paul

#17 lore raw
Quoted 9 lines · Paul Menage
Quoted 3 lines · Lennart Poettering

By default systemd will create its groups in the "debug" hierarchy, (at least for now, in the long run i'd like to see "noop" hierarchy or so, that doesn't sound so temporary), since that controller is not useful

If you just want to track processes, mount a (named) hierarchy with no attached subsystems.

Oh, that is possible? How would I do that?

This certainly doesn't work:

# mount waldo -t cgroup /tmp/xxxx -o defaults

Lennart

Signature · 3 lines
Lennart Poettering                        Red Hat, Inc.
lennart [at] poettering [dot] net
http://0pointer.net/lennart/           GnuPG 0x1A015CC4
#18 lore raw
Quoted 9 lines · Lennart Poettering
Quoted 7 lines · Paul Menage
Quoted 3 lines · Lennart Poettering

By default systemd will create its groups in the "debug" hierarchy, (at least for now, in the long run i'd like to see "noop" hierarchy or so, that doesn't sound so temporary), since that controller is not useful

Quoted 8 lines
Quoted 2 lines

If you just want to track processes, mount a (named) hierarchy with no attached subsystems.

Oh, that is possible? How would I do that?

This certainly doesn't work:

# mount waldo -t cgroup /tmp/xxxx -o defaults

An neither does this:

# mount waldo -t cgroup /tmp/xxxx -o name=systemd

(the mount() syscall fails with EINVAL here, the other one fails with EBUSY)

Lennart

Signature · 3 lines
Lennart Poettering                        Red Hat, Inc.
lennart [at] poettering [dot] net
http://0pointer.net/lennart/           GnuPG 0x1A015CC4
#19 lore raw
Quoted 18 lines · Lennart Poettering
Quoted 16 lines · Lennart Poettering
Quoted 9 lines · Paul Menage
Quoted 3 lines · Lennart Poettering

By default systemd will create its groups in the "debug" hierarchy, (at least for now, in the long run i'd like to see "noop" hierarchy or so, that doesn't sound so temporary), since that controller is not useful

If you just want to track processes, mount a (named) hierarchy with no attached subsystems.

Oh, that is possible? How would I do that?

This certainly doesn't work:

Quoted 8 lines
Quoted 1 line
# mount waldo -t cgroup /tmp/xxxx -o defaults

An neither does this:

# mount waldo -t cgroup /tmp/xxxx -o name=systemd

(the mount() syscall fails with EINVAL here, the other one fails with EBUSY)

Can you try the command below

mount -t cgroup cgroup -o none,name=hello /cgroup/

Works for me.

Signature · 2 lines
	Three Cheers,
	Balbir
#20 lore raw
Quoted 10 lines · Balbir Singh
Quoted 10 lines
Quoted 5 lines

Oh, that is possible? How would I do that?

This certainly doesn't work:

# mount waldo -t cgroup /tmp/xxxx -o defaults

An neither does this:

# mount waldo -t cgroup /tmp/xxxx -o name=systemd
Quoted 8 lines
Quoted 2 lines

(the mount() syscall fails with EINVAL here, the other one fails with EBUSY)

Can you try the command below

mount -t cgroup cgroup -o none,name=hello /cgroup/

Works for me.

That line certainly works, but unfortunately your own libcgroup completely ignores mount points like this. Meh.

Lennart

Signature · 3 lines
Lennart Poettering                        Red Hat, Inc.
lennart [at] poettering [dot] net
http://0pointer.net/lennart/           GnuPG 0x1A015CC4
#21 lore raw
Quoted 15 lines · Lennart Poettering
Quoted 13 lines · Balbir Singh
Quoted 12 lines
Quoted 5 lines

Oh, that is possible? How would I do that?

This certainly doesn't work:

# mount waldo -t cgroup /tmp/xxxx -o defaults

An neither does this:

# mount waldo -t cgroup /tmp/xxxx -o name=systemd

(the mount() syscall fails with EINVAL here, the other one fails with EBUSY)

Quoted 9 lines
Quoted 5 lines

Can you try the command below

mount -t cgroup cgroup -o none,name=hello /cgroup/

Works for me.

That line certainly works, but unfortunately your own libcgroup completely ignores mount points like this. Meh.

Lets fix it, we never thought of using named hierarchies, but it should not be too hard to fix.

Signature · 2 lines
	Three Cheers,
	Balbir
#22 lore raw
In reply to Lennart Poettering
Quoted 15 lines · Lennart Poettering
Quoted 13 lines · Balbir Singh
Quoted 12 lines
Quoted 5 lines

Oh, that is possible? How would I do that?

This certainly doesn't work:

# mount waldo -t cgroup /tmp/xxxx -o defaults

An neither does this:

# mount waldo -t cgroup /tmp/xxxx -o name=systemd

(the mount() syscall fails with EINVAL here, the other one fails with EBUSY)

Quoted 9 lines
Quoted 5 lines

Can you try the command below

mount -t cgroup cgroup -o none,name=hello /cgroup/

Works for me.

That line certainly works, but unfortunately your own libcgroup completely ignores mount points like this. Meh.

That be my mistake. I missed this update to cgroups. A patch will be coming out pretty soon!

Dhaval

#23 lore raw
In reply to Lennart Poettering
Quoted 8 lines · Lennart Poettering
Quoted 2 lines

If you just want to track processes, mount a (named) hierarchy with no attached subsystems.

Oh, that is possible? How would I do that?

This certainly doesn't work:

# mount waldo -t cgroup /tmp/xxxx -o defaults

mount waldo -t cgroup /tmp/xxxx -o none,name=foo

Paul

#24 lore raw
In reply to Lennart Poettering
Quoted 10 lines · Lennart Poettering
Quoted 9 lines · Lennart Poettering
Quoted 4 lines

See Dhaval's patch on the background of systemd
(http://0pointer.de/blog/projects/systemd.html). When a service is started in systemd, we create a cgroup for it, when it ends, we remove it.

I seriously hope that's optional, because I for one would really hate a system that does that. I still mostly build kernels with only cpuset in and really don't want anybody but me creating groups in there.

Quoted 5 lines

By default systemd will create its groups in the "debug" hierarchy, (at least for now, in the long run i'd like to see "noop" hierarchy or so, that doesn't sound so temporary), since that controller is not useful for anything but keeping track of processes. So it shouldn't bother you at all.

Will it still work with a CONFIG_CGROUP=n kernel? I see distributions deteriorate, you cannot even boot a raw bzImage kernel without initrd on most distros (sure, its not too hard to fix, but still).

Also, I get all kinds of dumb-ass init-script failures for not having modules but stuff built-in. A prime example is NFS failing on start on both fedora and ubuntu with a built-in nfs server (for different but both retarded reasons).

Requiring CONFIG_CGROUP=y to even get init running seems like a final straw to ensure nobody will ever get anything to boot these days.

#25 lore raw
Quoted 18 lines · Peter Zijlstra
Quoted 10 lines · Lennart Poettering
Quoted 9 lines · Lennart Poettering
Quoted 4 lines

See Dhaval's patch on the background of systemd
(http://0pointer.de/blog/projects/systemd.html). When a service is started in systemd, we create a cgroup for it, when it ends, we remove it.

I seriously hope that's optional, because I for one would really hate a system that does that. I still mostly build kernels with only cpuset in and really don't want anybody but me creating groups in there.

Quoted 5 lines

By default systemd will create its groups in the "debug" hierarchy, (at least for now, in the long run i'd like to see "noop" hierarchy or so, that doesn't sound so temporary), since that controller is not useful for anything but keeping track of processes. So it shouldn't bother you at all.

Quoted 3 lines

Will it still work with a CONFIG_CGROUP=n kernel? I see distributions deteriorate, you cannot even boot a raw bzImage kernel without initrd on most distros (sure, its not too hard to fix, but still).

No it won't work without cgroups.

Quoted 7 lines

Also, I get all kinds of dumb-ass init-script failures for not having modules but stuff built-in. A prime example is NFS failing on start on both fedora and ubuntu with a built-in nfs server (for different but both retarded reasons).

Requiring CONFIG_CGROUP=y to even get init running seems like a final straw to ensure nobody will ever get anything to boot these days.

Well, I wasn't aware that cgroups is now in the kernel for the purpose that people should *not* use it.

Next time something is added to the kernel please mark it as "Hey, please don't use it, this is only here so that you don't use it. Thanks!" Maybe then dumb-ass folks like me will notice and refrain from using it.

Requiring a single kernel options is not really too much to ask, is it? Don't be that conservative. systemd certainly won't require an initrd or anything else equally intrusive btw.

Lennart

Signature · 3 lines
Lennart Poettering                        Red Hat, Inc.
lennart [at] poettering [dot] net
http://0pointer.net/lennart/           GnuPG 0x1A015CC4
#26 lore raw
Quoted 37 lines · Lennart Poettering
Quoted 18 lines · Peter Zijlstra
Quoted 10 lines · Lennart Poettering
Quoted 9 lines · Lennart Poettering
Quoted 4 lines

See Dhaval's patch on the background of systemd
(http://0pointer.de/blog/projects/systemd.html). When a service is started in systemd, we create a cgroup for it, when it ends, we remove it.

I seriously hope that's optional, because I for one would really hate a system that does that. I still mostly build kernels with only cpuset in and really don't want anybody but me creating groups in there.

Quoted 5 lines

By default systemd will create its groups in the "debug" hierarchy, (at least for now, in the long run i'd like to see "noop" hierarchy or so, that doesn't sound so temporary), since that controller is not useful for anything but keeping track of processes. So it shouldn't bother you at all.

Quoted 3 lines

Will it still work with a CONFIG_CGROUP=n kernel? I see distributions deteriorate, you cannot even boot a raw bzImage kernel without initrd on most distros (sure, its not too hard to fix, but still).

No it won't work without cgroups.

Quoted 7 lines

Also, I get all kinds of dumb-ass init-script failures for not having modules but stuff built-in. A prime example is NFS failing on start on both fedora and ubuntu with a built-in nfs server (for different but both retarded reasons).

Requiring CONFIG_CGROUP=y to even get init running seems like a final straw to ensure nobody will ever get anything to boot these days.

Well, I wasn't aware that cgroups is now in the kernel for the purpose that people should *not* use it.

Quoted 9 lines

Next time something is added to the kernel please mark it as "Hey, please don't use it, this is only here so that you don't use it. Thanks!" Maybe then dumb-ass folks like me will notice and refrain from using it.

Requiring a single kernel options is not really too much to ask, is it? Don't be that conservative. systemd certainly won't require an initrd or anything else equally intrusive btw.

I think the config options are the domains of the distributors and if the code is there and works, most distros will enable it. As long as they have a feature that uses that option or a need for it.

I am not sure why CONFIG_CGROUP=y is so bad, Peter, could you elaborate?

Signature · 2 lines
	Three Cheers,
	Balbir
#27 lore raw
Quoted 1 line · Balbir Singh

I think the config options are the domains of the distributors

Whoever runs a distro kernel anyway? This is LKML, we're kernel devs.

Quoted 2 lines

I am not sure why CONFIG_CGROUP=y is so bad, Peter, could you elaborate?

Because it adds code I don't use and adds to the compile overhead.

#28 lore raw
Quoted 6 lines · Peter Zijlstra
Quoted 1 line · Balbir Singh

I think the config options are the domains of the distributors

Whoever runs a distro kernel anyway? This is LKML, we're kernel devs.

Heh! agreed, but we are a small population and moreover a large population would benefit from systemd and parallel boot.

Quoted 4 lines
Quoted 2 lines

I am not sure why CONFIG_CGROUP=y is so bad, Peter, could you elaborate?

Because it adds code I don't use and adds to the compile overhead.

Not anymore, if systemd becomes the default :-)

Signature · 2 lines
	Three Cheers,
	Balbir
#29 lore raw
Quoted 2 lines · Balbir Singh

Heh! agreed, but we are a small population and moreover a large population would benefit from systemd and parallel boot.

CONFIG_CGROUP=y isn't a requirement for parallel boot. People have been doing that for years without it.

And I'm not against systemd using cgroups per-se, I'm against it mandating it. It could simply not use them and not provide whatever it needs them for when not present.

CONFIG_CGROUP is an option, so people can say no.

Same for CONFIG_SYSFS, udev gets highly unhappy when disabled, but init still works and you do get a shell of some sort. If you pre-populate your /dev with static device nodes you can actually make it all the way to runlevel 3 the last time I tried.

#30 lore raw
Quoted 5 lines · Peter Zijlstra
Quoted 2 lines · Balbir Singh

Heh! agreed, but we are a small population and moreover a large population would benefit from systemd and parallel boot.

Quoted 9 lines

CONFIG_CGROUP=y isn't a requirement for parallel boot. People have been doing that for years without it.

And I'm not against systemd using cgroups per-se, I'm against it mandating it. It could simply not use them and not provide whatever it needs them for when not present.

CONFIG_CGROUP is an option, so people can say no.

I think that is reasonable. There should be a fallback for folks who want to run their own kernel (though I cannot imagine why they would want to turn off cgroups ;-) ).

Thanks!
Dhaval

#31 lore raw
In reply to Peter Zijlstra
Quoted 6 lines · Peter Zijlstra
Quoted 1 line · Balbir Singh

I think the config options are the domains of the distributors

Whoever runs a distro kernel anyway? This is LKML, we're kernel devs.

Well, sorry to bring that to you, but I didn't really design systemd as a development tool for lkml developers. Instead I designed it as a general purposes system manager.

Lennart

Signature · 3 lines
Lennart Poettering                        Red Hat, Inc.
lennart [at] poettering [dot] net
http://0pointer.net/lennart/           GnuPG 0x1A015CC4
#32 lore raw
In reply to Lennart Poettering
Quoted 5 lines · Lennart Poettering
Quoted 3 lines

Will it still work with a CONFIG_CGROUP=n kernel? I see distributions deteriorate, you cannot even boot a raw bzImage kernel without initrd on most distros (sure, its not too hard to fix, but still).

No it won't work without cgroups.

I guess we'll finally have an answer for people on #kernelnewbies on what distro is best suited for kernel development :-)

Quoted 5 lines
Quoted 2 lines

Requiring CONFIG_CGROUP=y to even get init running seems like a final straw to ensure nobody will ever get anything to boot these days.

Well, I wasn't aware that cgroups is now in the kernel for the purpose that people should *not* use it.

Init using the bare minimum possible only seems like a sensible thing. Once the basic stuff is running you can detect whats available and use it if needed/wanted.

I very often build a CONFIG_CGROUP=n kernel, I simply strip down my .config to the bare minimum because that builds fastest.

#33 lore raw
Quoted 3 lines · Peter Zijlstra

Init using the bare minimum possible only seems like a sensible thing. Once the basic stuff is running you can detect whats available and use it if needed/wanted.

I really think init should be able to run regardless of any CONFIG_* option. The only thing that should avoid init from running is not being able to mount the filesystem with init on it.

#34 lore raw
Quoted 9 lines · Peter Zijlstra
Quoted 3 lines · Peter Zijlstra

Init using the bare minimum possible only seems like a sensible thing. Once the basic stuff is running you can detect whats available and use it if needed/wanted.

I really think init should be able to run regardless of any CONFIG_* option. The only thing that should avoid init from running is not being able to mount the filesystem with init on it.

I suppose we'll continue to have alternative with the init= commandline option. If you look at the boot process today, we do already rely on features (CONFIG_*) for bootup. Changing the default to have CONFIG_CGROUP=y (without any of the controllers) would work, won't it? Is that too high an overhead/build or runtime wise?

Signature · 2 lines
	Three Cheers,
	Balbir