Slashdot Mirror
Systemd's Lennart Poettering: 'We Do Listen To Users'
M-Saunders writes: Systemd is ambitious and controversial, taking over a large part of the GNU/Linux base system. But where did it come from? Even Red Hat wasn't keen on it at the start, but since then it has worked its way into almost every major distro. Linux Voice talks to Lennart Poettering, the lead developer of Systemd, about its origins, its future, its relationship with Upstart, and handling the pressures of online flamewars.
I don't care bout the unix way, I don't care about if it's monolithic or not, I don't even care about how annoyed I am by the mere mention of his name.
I care about the fact that they seem to want to force their way into everything and everyone's business and ridicule anyone who tries to maintain a choice between systemd and other systems. (i.e Gentoo)
I'm a user and a hobby developer. No, I don't maintain 2000 servers, I don't need 2 second boot time, I don't need to hotswap drives. But I do need choices. I need to be able to decide what I want to use so I can get on with my fucking day and do what I want.
"But systemd is the best, why don't you want to use it?"
But Emacs!
But firefox!
But chrome!
But but but but!
The very first thing out of his mouth is a straw man.
This is not how to get people to change their minds.
You know how you hear that after a customer service call? Well Poettering's statement has the same meaning.
Well, do you actually take on board the concerns of system administrators and enterprise users?
What a lot of people are concerned about is that this entirely new and largely untested (in the 'wild', as it were) and very very large, complex piece of software which runs at a very very privileged level in the operating system is going to become the main source of security vulnerabilities in Linux.
Can we have a cut-down, simplified version of systemd for servers and doesn't try to replace several layers of server side system functionality such as logging?
Its clear that you listen to desktop users. How about listening to the system administrators?
In the free world the media isn't government run; the government is media run.
I am personally neutral on SystemD... but as someone in IT, it is quite worrisome that there is new, untested code sitting as the core userland... code that can make network connections, and has not ever seen any reviews or audits.
SystemD could be the best piece of coding on this planet... but without documentation or assurance that this is something trustworthy, a major security hole can cause major trouble. Network connections mean remote root holes. Even without that, there is the problem of local privilege escalation, which I worry hasn't been thought of, much less engineered to deal with. If there is a major show-stopper in SystemD that allows remote root, this can kill Linux as a whole in the enterprise.
This code was also forced on us, as in "you need to have SystemD on your job, or else you don't have a job". No transition time, no time to change applications to meet this, just "here you go. Deal with it. Better get used to binary logs, because it is that or nothing."
So, as someone who uses Linux in the enterprise, SystemD is something that is resulting in a lot resentment, due to time spent with making build documents, workarounds for existing applications, procedures to make custom code work... all for relatively little benefit other than "hey, this is new and shiny, and you have to deal with it."
I've been using GnuLinux for aabout two years now, I've mostly stuck around the 'buntu/Debian detivatives: Elementary OS, Ubuntu Studio, Crunchbang, Mint, primarily because I use GnuLinux fkr work and those always require me to fiddle with them the least (though Elementary OD has really been getting on my nerves after constantly having broken packages added). I understand the need for a freedom of choice because there are things some of us use our computers differently for, but for the life of me I can't understand why the fuck everyone hates SystemD to this degree. Yeah it's not always the best and causes some pain between kernel developers and SystemD developers, but DEATH THREATS OVER A GOD DAMN COMPONENT THAT YOU DON'T EVEN NOTICE IN USERSPACE... WHY.
He says it does not break the UNIX philosophy because everything is in the same code base purposely ignoring that it does not do one thing and do it well. He was creating a strawman.
When you cant win, ad hominem.
I too have some experience with SCO UX, HP UX, OSF/1 - when something was broken there, then it was broken. You could not really go and replace a DNS server with something else. Or the vi editor. Or syslog deamon. If it wasn't there you could wait for next release and cough up the money or you were SOL. You also could not take a package for HP-UX and install it on a BSD. Or recompile. What makes linux great is that if you don't like the component X then you can google up a replacement pretty quickly. It may not be so polished and it may need some work to get it working (because the most popular choices get most exposure and thus polish), but it is possible.
But we are now 1 or 2 decades later. We don't only run simple software on our machines. I fear the day when samba, JBoss, KDE, LibreOffice, GIMP, ... start to be dependent on systemd. When that happens it may or may not work for me. If it does, fine. If it does not then fixing the problem myself will be made complex exactly by difference of complexity between a shell script or alternative package installation and a C code. The may be low, but the potential loss is high.
I can understand the perspective that a single repository for more of the userspace resembles the *development* of traditional Unix systems, the argument made is usually not about where it is developed, but reducing the principle of having small simple utilities with straightforward interactions with other componets. For example, Most traditional Unix systems have terrible implementations of a shell interpreter and things like fileutils. It is an awkward, but not too terrible a situation since you can replace that stuff with GNU equivalents trivially without horribly breaking the OS. An administrator that understands enough to write scripts can discern the nature of interaction even if that administrator isn't a full-on software developer. systemd design trends in many ways toward requiring someone needing to dig in to have more development competency than previous designs. As a developer, I understand the attraction of some of the architecture choices, but I think they lose perspective of what it's like to be an administrator on the ground. Someone who doesn't live and breath your code has a harder time wrapping their heads around how it should be working when something requires customization, replacement, or debug.
In general, systemd is all-or-nothnig about a lot of things. They figure out a way to achieve what could be considered a sensible goal, but then go about it in highly disruptive ways. The sense is they throw up their hands and say 'well, this is the only way to do it, and it's worth it' rather than rethinking how the end could be achieved in a less disruptive way.
XML is like violence. If it doesn't solve the problem, use more.
Isn't the main problem that while systemd might solve problem, it's sharply going away from the simple solution that worked to make Unix good?
Systemd isn't simple. If it's not simple, I don't think I want it on my Linux.
PA and Gnome isn't simple either. And creating more problems (albeit while solving others). I believe the same thing will be true about systemd.
Linux has almost two orders of magnitude more code than systemd, and it changes all the time. Security vulnerabilities are far more likely to be in the monolithic kernel.
Higher Logics: where programming meets science.
It's a lot better than openrc, which is needlessly slow due to being written in bash and fails at running tasks that don't depend on each other in parallel. I've converted both my desktop and laptop and now more concerned with keeping openrc away from Gentoo.
OpenRC is written in C for the most part. Each init script is shell based though and works fine with pretty much any shell.
You can use bash if you want to, but I prefer to run dash.
As to the parallel start up - well, some users do have an issue depending on what services they have installed and configured.
I personally have no problem with it and use it all the time.
As to the speed? Well, it gets me to the desktop in the same number of seconds as systemd.
You can use syslog but you cannot get rid of journald, it has to be there running, increasing overhead. This is not, and has never been about learning something knew, that is nothing more than a fallacy created by the pro systemd movement to attack the people who dislike it.
When you cant win, ad hominem.
How many professional SysAdmins and enterprise users are regularly tinkering with their init settings? It is usually a set it and forget it type of thing.
As I see it, this is just general IT Ranting because something is new.
If something is so important that you feel the need to post it on the internet... It probably isn't that important.
Exactly! I have used openRC since it was in beta and it works really really well. Parallel boot works well, the cgroups container stuff works well as well (before some processes were just not being fully killed...)
My system boots equally fast to desktop as with systemd. The major speedup for me was NOTHING todo with openRC or systemd... it was HDD -> SSD (even before sysd ~= openrc).
Only slow thing is dhcpcd but that is more router based then openrc/dhcpcd/sysd.
OpenRC is really really good.
Its one tool, that does many things and does them typically poorly compared to the replacement tools. Systemd does multiple things and does them poorer then what they replaced, therefore it does not do one thing, let alone well. He is trying to redefine systemd away from being the tool and just being a repository, which utterly fails due to some components requiring others in systemd.
When you cant win, ad hominem.
users: Systemd is broken, undocumented and a single point of failure
Pottering: no ones forcing you to use it, use something else.
users: KDE and Gnome wont work without it and you never fixed pulseaudio, which is now default in almost every distro.
Pottering: no ones forcing you to use it, use something else
users: Why is there binary logging? I cant grep anything and dont know why the system crashed. the way user switching works is a huge security hole
pottering:no ones forcing you to use it, use something else
DEBIAN USERS:: Lets seriously reconsider the use of SystemD. its very controversial, it flies against the unix ethos, and there are some valid points raised about it security
open source community: we've forked it and made it slightly more useful.
Pottering: HOLD ON WE DO LISTEN TO USERS!!
Good people go to bed earlier.
I fear the day when samba, JBoss, KDE, LibreOffice, GIMP, ... start to be dependent on systemd.
When I was looking at systemd, one thing I wanted to see in the documentation is how to convert my own home-brew daemons to interface with it properly. Specifically, how to take SysVInit based starts and convert them to use systemd and journald. (Ditto taking UpStart scripts and convert to systemd.) The result needs to work exactly like daemons running under SysVInit. I spent three weeks with CentOS 6 trying to get my daemons to work right under UpStart, and never did get the exact functionality. I had to go back to crontabs for some of the work! So this is not an idle concern to me.
One of the gripes I have is that I want the University of Delaware version of NTP running on my edge boxes. As the group there make tweaks to NTP based on their continuing research, I don't want to wait for another group to do a re-port. That's why I would like to see a published way to interface with systemd/journald that would have minimum impact on the rest of the code base for a daemon.
I can see where daemons need to change. But do they have to be rewritten?
Then why do they complain about systemd when it's not a UNIX component, but a Linux one? If UNIX philosophy is so important, why do they have double standards that they don't apply the same argument to Linux?
Those who do not learn from commit history are doomed to regress it.
Lennart is right about being more UNIX like.
Wait, what?
*reads TFA*
Hahahaha, oh well:
Lennart Poettering: [...] most people who say Systemd is un-Unixish have no idea what Unix is actually like.
What’s typical for Unix, for example, is that all the tools, the C library, the kernel, are all maintained in the same repository, right? And they’re released in sync, have the same coding style, the same build infrastructure, the same release cycles – everything’s the same. So you get the entire central part of the operating system like that. If people claim that, because we stick a lot of things into the Systemd repository, then it’s un-Unixish, then it’s absolutely the opposite. It’s more Unix-ish than Linux ever was!
The Linux model is the one where you have everything split up, and have different maintainers, different coding styles, different release cycles, different maintenance statuses. Much of the Linux userspace used to be pretty badly maintained, if at all. You had completely different styles, the commands worked differently – in the most superficial level, some used -h for help, and others ––help. It’s not uniform.
If we put a lot of the glue in one repository, it’s not all the way towards Unix, but it’s half way between traditional Linux and traditional Unix. We do not put libc and the kernel in the same repository, just the basic things. So that’s a misconception that I’m always bemused about, and I’m pretty sure that most people who claim that have never actually played around with Unix at all.
Wow... Just.. wow.
TL;DR his sole argument for systemd being "like traditional unix" is that they're maintaining it in one (as opposed to dozens of) source code repos.
I think this is the dumbest reasoning i've ever heard. I also like how he calls systemd non-monolithic, of course, without giving any reason for why that is.
CLI paste? paste.pr0.tips!
Systemd does multiple things and does them poorer then what they replaced, therefore it does not do one thing,
Citation needed. Please elaborate on any things that Systemd does worse than something that it replaced. Specifics would be appreciated.
I know very little about init, or Systemd, but what I do know is the very basic idea of how they both work. Init works, just like the documentation says, by starting system components in the order specified by the init scripts. These scripts are structured such that when a particular component is done starting, it will then trigger the start of another set of components. I can tell you that this is a hideously malformed way to start a system. If I have a configurable system and want to bring up component x, but it requires a list of 50 components are up first, then i need to look through all of that configuration to figure out which components should trigger mine to start up. This is backwards from how it should be.
Systemd works the problem backwards. I tell it what things my component needs to have running first, and Systemd figures out what order to boot things. It is smarter, faster, and conceptually better in every conceivable way. The particular implementation may or may not be good, but the algorithm is far superior, which is why it is being universally adopted. Much of the rest of Systemd is a result of the fact that any init system will have to touch on all of these other areas of the system. Init has to handle logging. It also has to handle system configuration (udev). It will also have to touch upon process management, and resource allocation. It is also the logical place to put any kind of hot swap functionality for devices, as the init system will largely be handling hardware interaction modules, and many of the system component dependencies are hardware dependencies and not just software dependencies. In all the problem is very complex, and I'm glad to see someone actually tackling it intelligently.
As with all things Linux, if you don't like it you're free to present an alternative of your own, but don't get huffy when people choose Systemd over what you recommend, because they are choosing for them. You are quite free to choose for you. In the end, if you don't like it vote with your money, and choose a different distribution, or OS.
I wish I had a good sig, but all the good ones are copyrighted
"Their impotent wails of despair give us sustenance."
I'm no expert but systemd seems to be a collection of smaller components that work together. It isn't monolithic, it's lots of small parts that happen to be from the same repository and happen to be released together, the same way that GNU tools, the kernel and libc are.
Is that factually incorrect?
const int one = 65536; (Silvermoon, Texture.cs)
SJW, n: "Someone I don't like, and by the way I'm a fuckwit" - AC
According to wikipedia: "The Unix philosophy emphasizes building short, simple, clear, modular, and extensible code that can be easily maintained and repurposed by developers other than its creators. The Unix philosophy favors composability as opposed to monolithic design.".
Okay, so how exactly does systemd violate this ?
There's more to it than that, and systemd also violates some of those principles anyway; many here have complained about the lack of code quality. But the Unix philosophy also includes a love for flat, human-readable files, and systemd's syslog shits on that. You have to run yet another syslog to even get text logging, and it's a second-class citizen — it gets the log messages after the binary logging system gets them.
Also, systemd is a thing without a reason to exist. It doesn't actually provide anything we didn't have before. It exists purely due to Lennart's NIH syndrome, and for no other reason. As others have pointed out, openrc does the things which systemd's init functionality does. That means that its original basic reason for existence is nonsensical. As many including myself have pointed out, most of it can be handled by very small shell scripts. Some rail against this, but shell scripting is also part of the Unix philosophy. That's part of the core idea of the operating system! There's nothing wrong with using scripting to make things happen.
"You're right," Fisheye says. "I should have set it on 'whip' or 'chop.'"
Systemd does startup,
journald does logging,
ntpd is configurable option
- so try again
"The hands that help are better far than lips that pray." - Robert Ingersoll (1833-1899)
can i run systemd without journald? can i run journald without systemd? if not, the point is made.
Basically, it's not factually incorrect, but very misleading. Sure, they are separate components but they are so tightly coupled you can't really have one without theother so they operate in the same way as a monolithic system despite being split up into multiple components. Facllacy #1 explains it much better than I could here.
Because journald is part of systemd, it is able to start logging earlier in the boot process and continue logging later in to the shutdown process. This is an improvement over syslogd.
look, either journald is part of systemd or it isn't. If it is, then systemd does multiple things, and should be broken up into more parts. If it isn't, then your argument is nonsense. The truth is that it is sort of both, but only in all the worst ways. journald and systemd depend on one another, so you have to run them both. So in that way, they are part of the same thing. But wait! journald is actually another process. There's no reason another syslogd couldn't have been modified to permit it to save logs in memory until the log storage filesystem was mounted, so that it could be started very early in the boot process and be able to capture logging information for everything. But instead, we got an extra-special log daemon which depends on the extra-special init daemon which provides no functionality not already provided by OpenRC.
So yes, the early boot logging (though nothing else) is an improvement over existing syslogds. However, the only reason which it was implemented in a journald-specific fashion is that Lennart was deliberately trying to break interoperability to force you to use his syslogd. If something was NIH, he won't use it and considers it inferior to his new, improperly tested code. And we have no reason to trust him; his prior claim to fame is an unfinished nightmare which again has no reason to exist. JACK was around when pulseaudio was created, and spending the effort on making JACK more user-friendly rather than creating a new daemon which shits the bed much of the time would have been better for everyone except Lennart. And that's precisely the situation we have today: we've got a new init+everyotherfuckingthing daemon which often shits all over itself, which is being hailed as the solution to some comparatively minor problems we used to have where it would have been nice to have some more logging, and where some very stupid people can't understand init scripts but want to be able to call themselves Unix admins anyway. So now init scripts are evil, and unit files are the best thing evar.
"You're right," Fisheye says. "I should have set it on 'whip' or 'chop.'"
First, Systemd is neither unwanted nor dangerous, until and unless you can give me a specific example.
This thread is full of evidence of both. Don't be deliberately disingenuous, nobody likes a liar.
No one is putting Systemd into stable releases yet, its still going through the vetting phase.
Yes, that's why we are arguing against it now, to try to prevent it from becoming a part of "stable" releases. Because it isn't.
Third, are you running Upstart? That was a new technology once. It also had to be vetted, but You would be laughed out if you referred to Upstart as unwanted and dangerous
Not at all. Many felt that way about it, too. But the impact was not as widespread, so neither was the interest.
The dastardly way Pottering got all of these distros to switch to Systemd was to present it on its merits!
False. Systemd was used for some downstream projects (like GNOME) because at the time, the existing interfaces for doing certain things were in flux. Now they aren't, and the systemd dependency is coming out of GNOME.
Systemd is winning, and quickly, because
...embrace and extend. HTH, HAND.
"You're right," Fisheye says. "I should have set it on 'whip' or 'chop.'"
Wrong. That base still wouldn't boot my server for me and the systemd people would still be spinning in circles unable to even conceive of a way to fix it. You see, I want the server to boot w/ btrfs in degraded mode should it suffer a drive failure. But systemd won't do it.
I don't know about Suse, byt Red Hat does not. Otherwise they'd have noticed that sysadmins are sticking with RHEL6 to avoid systemd trouble.
So you trust that the journald binary reads the "don't save data" boolean value and doesn't just ignore it, or worse, ignores it and executes this shell script:
Or, more plausibly, does all that in a binary blob? Sure. It's open source. Sure I can check the code and compile it myself to make sure it meets my need for security. But one of the things about using these "pre-built" distros is that I'm probably using it to save time and money, which means I don't want to be bothered with doing a code check and recompile on every single init package. That's the beauty of init scripts that everyone has apparently missed in this debate. One human readable script for each daemon running, so the configuration of a daemon can be gleaned over for any questionable bits and edited in less than 10 minutes. And being scripts, they're all plain text that's automatically executable. I don't need to read over source, find an issue, edit it out, and then recompile the entire init code into a binary for that daemon to make use of it. That goes for PID 1 as well. If it's not a script that can be quickly edited and then it's ready for the next boot cycle without wasting process cycles for recompilation I don't want it on my production server.
There is a confusion of two aspects of "monolithic" here, and unfortunately Poettering did not clarify it well:
1) "Monolithic" in terms of a single repository for all code. The systemd project is monolithic in this respect, and Poettering is absolutely correct that this is the classic Unix way. All the *BSDs are maintained this way. Linux is thus, as he correctly points out, the anomoly.
2) "Monolithic" in terms of tools that depend on each other. The systemd system is not monolithic in this respect. The only two required components are journald and udev. Everything else is entirely optional and replaceable, but "recommended" in the sense that the people working on the project really think that these components, written from scratch, are of better quality and consistency than the existing components they replace. But some hysterical people hear this recommendation as "forcing it down our throats". Distro makers will decide which components to use, whether those in the systemd project or the existing ones. Obviously, the existing ones have the benefit of maturity.
Also, he doesn't point this out in this interview, but these new components are also better at reporting errors in a way that the whole init would be more robust when certain components have partial failures (and systemd knows how to deal with them). This is especially crucial for servers with complicated, layered network stacks. People say that systemd is for desktops, but really it is just as important for servers to have a robust initialization of services.