3 ms·
systemd DOES NOT solve the PID file race. What is does is poll a cgroups proc file that lists the PIDs in a cgroup, then iteratively calls kill on those PIDs. B
by wahern 10y ago
systemd DOES NOT solve the PID file race. What is does is poll a cgroups proc file that lists the PIDs in a cgroup, then iteratively calls kill on those PIDs. But this is _just_ as racy as a regular PID file. I explain more here, with links to the relevant bits of code:
https://lwn.net/Articles/677671/
Long story short, Linux does not offer a way to atomically send a signal to a cgroup, and so there's no way for systemd to reliably kill errant (or worse, malicious) processes that keep forking. Worse, last time I checked systemd had a bug in their read-iterate-kill loop that could lead to an infinite loop. I also detail that issue in the above LWN thread.
If you _carefully_ parse Pottering's statements regarding systemd, a charitable interpretation would be that he never claimed systemd solved the PID race for uncooperative software. Unfortunately, everybody believed and most people still believe that it does. Afterall, there was never a problem with PID races with _cooperative_ software, so it was natural to assume that what systemd was bringing to the table was a solution to uncooperative processes.
That doesn't mean systemd isn't slightly better then `killall [process name pattern]`. But in security an inherently broken solution isn't any solution at all.
- viraptor 10y ago> systemd DOES NOT solve the PID file race I did not claim otherwise. And I wouldn't even describe it as PID file race. PID files are a specific thing that was used with older inits. I don't believe any init can solve the issue you're describing - it exists on a different layer. But cgroups freezer should be able to solve it.
- wahern 10y agoI thought your question implied that systemd was superior to PID files because it solved the PID race. To answer your question more directly, why do I use PID files: 1) Because I write and value portable software, both across different Linux distros and across different POSIX-like systems. I regularly target AIX, FreeBSD, NetBSD, OpenBSD, OS X, and Solaris; none as second class citizens. 2) Because IME the compile-test-debug cycle and similar non-production runtime modes is easier when you don't have to fiddle with separate init files. Supporting a simple PID-file-based backgrounding capability directly in your software is a relatively simple matter when not implemented as an after-thought. 3) Because sometimes you want to implement a service using multiple processes (e.g. worker pools, specialized privilege separation, etc), which is easier (both in development and production) when you fork them from your own master rather than trying to configure and coordinate through a third-party supervisor. Note that this doesn't exclude your service's supervisor running in the foreground under another supervisor like init (e.g. systemd) or daemontools. 4) Because using process groups and a shared controlling pseudo-terminal you _can_ atomically send a signal to all children in a process group. It's more robust than what systemd currently does with cgroups, it's portable as a practical matter, and relatively simple to accomplish early in main(). Note that I write my software to support running in the foreground under the control of any supervisor of choice, including support for inheriting a listening socket. This is always the default mode. Backgrounding, PID files, etc, are optional capabilities in my daemons. Regarding cgroups freezer, it does seem like it should work. I stand corrected wrt Linux supporting atomic signals to an entire cgroup. But it seems like neither systemd nor Docker has actually implemented support. Perhaps it's for lack of motivation, or perhaps because there are non-trivial issues to resolve. It would be interesting to know what the hold up is.