On Aug 15, 2012 3:32 PM, "Felipe Contreras" <felipe.contreras@xxxxxxxxx>
wrote:
>
> On Wed, Aug 15, 2012 at 2:16 PM, Thomas Bächler <thomas@xxxxxxxxxxxxx>
wrote:
> > Am 15.08.2012 14:01, schrieb Felipe Contreras:
> >> On Wed, Aug 15, 2012 at 1:55 PM, Thomas Bächler <thomas@xxxxxxxxxxxxx>
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
there.
> >
> >>>>>> 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
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
