On Aug 15, 2012 3:32 PM, "Felipe Contreras" <felipe.contreras@gmail.com> wrote:
On Wed, Aug 15, 2012 at 2:16 PM, Thomas Bächler <thomas@archlinux.org>
Am 15.08.2012 14:01, schrieb Felipe Contreras:
On Wed, Aug 15, 2012 at 1:55 PM, Thomas Bächler <thomas@archlinux.org> wrote:
Am 15.08.2012 13:34, schrieb Felipe Contreras:
> 1./ Be a small simple binary
The systemd main binary is not very large (larger than sysvinit's /sbin/init, but not by much).
But that binary alone is useless, and certainly not *simple*.
/sbin/init from sysvinit alone is useless. What is your point?
The rest are rather simple scripts (in the case of Arch Linux).
And you are still ignoring the fact that systemd is anything but *simple*. How convenient to ignore that argument.
What argument? You _claim_ that it isn't simple, but you do not give any proof for that claim.
It is general knowledge that scripting languages are generally simpler than compiling languages.
But fine, compare a few lines of rc.sysinit:
# mount the API filesystems # /proc, /sys, /run, /dev, /run/lock, /dev/pts, /dev/shm mountpoint -q /proc || mount -t proc proc /proc -o nosuid,noexec,nodev mountpoint -q /sys || mount -t sysfs sys /sys -o nosuid,noexec,nodev mountpoint -q /run || mount -t tmpfs run /run -o mode=0755,nosuid,nodev mountpoint -q /dev || mount -t devtmpfs dev /dev -o mode=0755,nosuid mkdir -p /dev/{pts,shm} mountpoint -q /dev/pts || mount -t devpts devpts /dev/pts -o mode=0620,gid=5,nosuid,noexec mountpoint -q /dev/shm || mount -t tmpfs shm /dev/shm -o mode=1777,nosuid,nodev
To their equivalent in systemd:
--- #include <unistd.h> #include <fcntl.h> #include <errno.h> #include <string.h> #include <sys/stat.h> #include <sys/wait.h> #include <mntent.h>
#include "log.h" #include "util.h" #include "path-util.h" #include "set.h" #include "mount-setup.h" #include "exit-status.h"
/* Goes through /etc/fstab and remounts all API file systems, applying * options that are in /etc/fstab that systemd might not have * respected */
int main(int argc, char *argv[]) { int ret = EXIT_FAILURE; FILE *f = NULL; struct mntent* me; Hashmap *pids = NULL;
if (argc > 1) { log_error("This program takes no argument."); return EXIT_FAILURE; }
log_set_target(LOG_TARGET_AUTO); log_parse_environment(); log_open();
umask(0022);
f = setmntent("/etc/fstab", "r"); if (!f) { if (errno == ENOENT) { ret = EXIT_SUCCESS; goto finish; }
log_error("Failed to open /etc/fstab: %m"); goto finish; }
pids = hashmap_new(trivial_hash_func, trivial_compare_func); if (!pids) { log_error("Failed to allocate set"); goto finish; }
ret = EXIT_SUCCESS;
while ((me = getmntent(f))) { pid_t pid; int k; char *s;
/* Remount the root fs, /usr and all API VFS */ if (!mount_point_is_api(me->mnt_dir) && !path_equal(me->mnt_dir, "/") && !path_equal(me->mnt_dir, "/usr")) continue;
log_debug("Remounting %s", me->mnt_dir);
pid = fork(); if (pid < 0) { log_error("Failed to fork: %m"); ret = EXIT_FAILURE; continue; }
if (pid == 0) { const char *arguments[5]; /* Child */
arguments[0] = "/bin/mount"; arguments[1] = me->mnt_dir; arguments[2] = "-o"; arguments[3] = "remount"; arguments[4] = NULL;
execv("/bin/mount", (char **) arguments);
log_error("Failed to execute /bin/mount: %m"); _exit(EXIT_FAILURE); }
/* Parent */
s = strdup(me->mnt_dir); if (!s) { log_oom(); ret = EXIT_FAILURE; continue; }
k = hashmap_put(pids, UINT_TO_PTR(pid), s); if (k < 0) { log_error("Failed to add PID to set: %s", strerror(-k)); ret = EXIT_FAILURE; continue; } }
while (!hashmap_isempty(pids)) { siginfo_t si; char *s;
zero(si); if (waitid(P_ALL, 0, &si, WEXITED) < 0) {
if (errno == EINTR) continue;
log_error("waitid() failed: %m"); ret = EXIT_FAILURE; break; }
s = hashmap_remove(pids, UINT_TO_PTR(si.si_pid)); if (s) { if (!is_clean_exit(si.si_code, si.si_status, NULL)) { if (si.si_code == CLD_EXITED) log_error("/bin/mount for %s exited with exit status %i.", s, si.si_status); else log_error("/bin/mount for %s terminated by signal %s.", s, signal_to_string(si.si_status));
ret = EXIT_FAILURE; }
free(s); } }
finish:
if (pids) hashmap_free_free(pids);
if (f) endmntent(f);
return ret; } ---
If you think the second one is simpler, then I don't you know what 'simple' means.
> 2./ Have no dependencies
That is pure BS. If something has no dependencies, it has to do everything in the binary itself. You either end up with no features, or potential for tons of bugs.
Having NO dependencies also means you have to bypass the C library and implement everything from scratch - that is the worst idea ever.
No need to overreact, the meaning is clear:
2. Have as few dependencies as possible, preferably dependencies that are used widely in most systems and that have few dependencies themselves, and are simple themselves
Okay, where exactly does systemd violate that?
d-bus, for starters.
Dependencies that are * used widely - check
Not as widely as shell, and libc, and util-linux. Some Arch Linux users don't use D-Bus, in fact, and it's not by default added to rc.conf precisely for that reason.
* in most systems - check
Less than the Arch Linux systems that use initscripts.
* have few dependencies themselves - check
libx11 is a cheap dependency for you?
* are simple themselves - ahemm
D-Bus is extremely complicated. It's more than 100k likes of code.
So, dbus almost qualifies. You said "for starters", what others are
> 3./ Be easy to follow, fix and lockdown, best fit being interpreted > languages.
So, init should be a small binary in an interpreted language? Am I
wrote: there. the
only one who notices you are contradicting yourself.
No. The "services" (in systemd lingo) should be in an interpreted language: e.g. shell.
Why should they be? As far as I understand, they're human-readable text files. One might say this is an "interpreted language".
No, they are compiled binaries. The code is in C (not interpreted).
Ah, you mean those. You do realize that we now used many of those tools in our initscripts, and I don't see you complaining about that.
That is dangerous, but not as dangerous as going full systemd.
But anyway, I am merely explaining what #3 means IMO.
There's probably plenty of reasons why they are in C, I don't know them. In any case, I don't see how making something in a scripting language is simpler - in contrast, I always find that writing a small C program for a task is easier and the result is more robust than a script.
And I find completely the opposite to be the case. Scripts are easier to write, read, and debug.
But you are not the one writing or debugging our initscripts.
I'll stop discussing with you now, as this will lead nowhere. The fact remains that all you do is complain, instead of providing an alternative. The decisions are being made by the people who actually _maintain_ this stuff inside Arch.
The alternative is simple: stay with initscripts *at least* until the problems with systemd are sorted out.
I just subscribed to this list, and 80% of the traffic I'm seeing is problems with systemd. That should tell you something; systemd has problems.
Please read the discussions that happened regarding systemd before you joined. You are repeating old arguments. Tom