Changeset 2725 in MondoRescue for branches/2.2.9/mindi-busybox/runit

Timestamp:

Feb 25, 2011, 9:26:54 PM (13 years ago)

Author:

Bruno Cornec

Message:

• Update mindi-busybox to 1.18.3 to avoid problems with the tar command which is now failing on recent versions with busybox 1.7.3

Location:

branches/2.2.9/mindi-busybox/runit

Files:

• Config.in (modified) (9 diffs)
• Config.src (added)
• Kbuild (modified) (1 diff)
• Kbuild.src (added)
• chpst.c (modified) (6 diffs)
• runit_lib.h (modified) (3 diffs)
• runsv.c (modified) (28 diffs)
• runsvdir.c (modified) (9 diffs)
• sv.c (modified) (19 diffs)
• svlogd.c (modified) (47 diffs)

branches/2.2.9/mindi-busybox/runit/Config.in

@@ +1 @@
+# DO NOT EDIT. This file is generated from Config.src
 #
 # For a description of the syntax of this configuration file,
@@ -6 +7 @@
 menu "Runit Utilities"
 
+
+
 config RUNSV
     bool "runsv"
-    default n
+    default y
     help
       runsv starts and monitors a service and optionally an appendant log
@@ -15 +18 @@
 config RUNSVDIR
     bool "runsvdir"
-    default n
+    default y
     help
       runsvdir starts a runsv process for each subdirectory, or symlink to
@@ -21 +24 @@
       subdirectories, and restarts a runsv process if it terminates.
 
+config FEATURE_RUNSVDIR_LOG
+    bool "Enable scrolling argument log"
+    depends on RUNSVDIR
+    default n
+    help
+      Enable feature where second parameter of runsvdir holds last error
+      message (viewable via top/ps). Otherwise (feature is off
+      or no parameter), error messages go to stderr only.
+
 config SV
     bool "sv"
-    default n
+    default y
     help
       sv reports the current status and controls the state of services
       monitored by the runsv supervisor.
 
+config SV_DEFAULT_SERVICE_DIR
+    string "Default directory for services"
+    default "/var/service"
+    depends on SV
+    help
+      Default directory for services.
+      Defaults to "/var/service"
+
 config SVLOGD
     bool "svlogd"
-    default n
+    default y
     help
       svlogd continuously reads log data from its standard input, optionally
@@ -38 +58 @@
 config CHPST
     bool "chpst"
-    default n
+    default y
     help
       chpst changes the process state according to the given options, and
@@ -45 +65 @@
 config SETUIDGID
     bool "setuidgid"
+    default y
     help
       Sets soft resource limits as specified by options
@@ -50 +71 @@
 config ENVUIDGID
     bool "envuidgid"
+    default y
     help
       Sets $UID to account's uid and $GID to account's gid
@@ -55 +77 @@
 config ENVDIR
     bool "envdir"
+    default y
     help
       Sets various environment variables as specified by files
@@ -61 +84 @@
 config SOFTLIMIT
     bool "softlimit"
+    default y
     help
       Sets soft resource limits as specified by options

branches/2.2.9/mindi-busybox/runit/Kbuild

@@ +1 @@
+# DO NOT EDIT. This file is generated from Kbuild.src
 # Makefile for busybox
 #
 # Copyright (C) 1999-2005 by Erik Andersen <andersen@codepoet.org>
 #
-# Licensed under the GPL v2, see the file LICENSE in this tarball.
+# Licensed under GPLv2, see file LICENSE in this source tree.
 
 lib-y:=
-lib-$(CONFIG_RUNSV) += runsv.o runit_lib.o
-lib-$(CONFIG_RUNSVDIR) += runsvdir.o runit_lib.o
-lib-$(CONFIG_SV) += sv.o runit_lib.o
-lib-$(CONFIG_SVLOGD) += svlogd.o runit_lib.o
+
+
+
+lib-$(CONFIG_RUNSV) += runsv.o
+lib-$(CONFIG_RUNSVDIR) += runsvdir.o
+lib-$(CONFIG_SV) += sv.o
+lib-$(CONFIG_SVLOGD) += svlogd.o
 lib-$(CONFIG_CHPST) += chpst.o
 

branches/2.2.9/mindi-busybox/runit/chpst.c

@@ -26 +26 @@
 */
 
-/* Busyboxed by Denis Vlasenko <vda.linux@googlemail.com> */
+/* Busyboxed by Denys Vlasenko <vda.linux@googlemail.com> */
 /* Dependencies on runit_lib.c removed */
 
 #include "libbb.h"
 
-#include <dirent.h>
-
-// Must match constants in chpst_main!
-#define OPT_verbose  (option_mask32 & 0x2000)
-#define OPT_pgrp     (option_mask32 & 0x4000)
-#define OPT_nostdin  (option_mask32 & 0x8000)
-#define OPT_nostdout (option_mask32 & 0x10000)
-#define OPT_nostderr (option_mask32 & 0x20000)
-
-static char *set_user;
-static char *env_user;
-static const char *env_dir;
-static long limitd = -2;
-static long limits = -2;
-static long limitl = -2;
-static long limita = -2;
-static long limito = -2;
-static long limitp = -2;
-static long limitf = -2;
-static long limitc = -2;
-static long limitr = -2;
-static long limitt = -2;
-static int nicelvl;
-static const char *root;
-
-static void suidgid(char *user)
-{
-    struct bb_uidgid_t ugid;
-
-    if (!get_uidgid(&ugid, user, 1)) {
-        bb_error_msg_and_die("unknown user/group: %s", user);
-    }
-    if (setgroups(1, &ugid.gid) == -1)
-        bb_perror_msg_and_die("setgroups");
-    xsetgid(ugid.gid);
-    xsetuid(ugid.uid);
-}
-
-static void euidgid(char *user)
-{
-    struct bb_uidgid_t ugid;
-
-    if (!get_uidgid(&ugid, user, 1)) {
-        bb_error_msg_and_die("unknown user/group: %s", user);
-    }
-    xsetenv("GID", utoa(ugid.gid));
-    xsetenv("UID", utoa(ugid.uid));
-}
-
-static void edir(const char *directory_name)
+/*
+Five applets here: chpst, envdir, envuidgid, setuidgid, softlimit.
+
+Only softlimit and chpst are taking options:
+
+# common
+-o N            Limit number of open files per process
+-p N            Limit number of processes per uid
+-m BYTES        Same as -d BYTES -s BYTES -l BYTES [-a BYTES]
+-d BYTES        Limit data segment
+-f BYTES        Limit output file sizes
+-c BYTES        Limit core file size
+# softlimit
+-a BYTES        Limit total size of all segments
+-s BYTES        Limit stack segment
+-l BYTES        Limit locked memory size
+-r BYTES        Limit resident set size
+-t N            Limit CPU time
+# chpst
+-u USER[:GRP]   Set uid and gid
+-U USER[:GRP]   Set $UID and $GID in environment
+-e DIR          Set environment variables as specified by files in DIR
+-/ DIR          Chroot to DIR
+-n NICE         Add NICE to nice value
+-v              Verbose
+-P              Create new process group
+-0 -1 -2        Close fd 0,1,2
+
+Even though we accept all these options for both softlimit and chpst,
+they are not to be advertised on their help texts.
+We have enough problems with feature creep in other people's
+software, don't want to add our own.
+
+envdir, envuidgid, setuidgid take no options, but they reuse code which
+handles -e, -U and -u.
+*/
+
+enum {
+    OPT_a = (1 << 0) * ENABLE_SOFTLIMIT,
+    OPT_c = (1 << 1) * (ENABLE_SOFTLIMIT || ENABLE_CHPST),
+    OPT_d = (1 << 2) * (ENABLE_SOFTLIMIT || ENABLE_CHPST),
+    OPT_f = (1 << 3) * (ENABLE_SOFTLIMIT || ENABLE_CHPST),
+    OPT_l = (1 << 4) * ENABLE_SOFTLIMIT,
+    OPT_m = (1 << 5) * (ENABLE_SOFTLIMIT || ENABLE_CHPST),
+    OPT_o = (1 << 6) * (ENABLE_SOFTLIMIT || ENABLE_CHPST),
+    OPT_p = (1 << 7) * (ENABLE_SOFTLIMIT || ENABLE_CHPST),
+    OPT_r = (1 << 8) * ENABLE_SOFTLIMIT,
+    OPT_s = (1 << 9) * ENABLE_SOFTLIMIT,
+    OPT_t = (1 << 10) * ENABLE_SOFTLIMIT,
+    OPT_u = (1 << 11) * (ENABLE_CHPST || ENABLE_SETUIDGID),
+    OPT_U = (1 << 12) * (ENABLE_CHPST || ENABLE_ENVUIDGID),
+    OPT_e = (1 << 13) * (ENABLE_CHPST || ENABLE_ENVDIR),
+    OPT_root = (1 << 14) * ENABLE_CHPST,
+    OPT_n = (1 << 15) * ENABLE_CHPST,
+    OPT_v = (1 << 16) * ENABLE_CHPST,
+    OPT_P = (1 << 17) * ENABLE_CHPST,
+    OPT_0 = (1 << 18) * ENABLE_CHPST,
+    OPT_1 = (1 << 19) * ENABLE_CHPST,
+    OPT_2 = (1 << 20) * ENABLE_CHPST,
+};
+
+/* TODO: use recursive_action? */
+static NOINLINE void edir(const char *directory_name)
 {
     int wdir;
@@ -89 +102 @@
     wdir = xopen(".", O_RDONLY | O_NDELAY);
     xchdir(directory_name);
-    dir = opendir(".");
-    if (!dir)
-        bb_perror_msg_and_die("opendir %s", directory_name);
+    dir = xopendir(".");
     for (;;) {
+        char buf[256];
+        char *tail;
+        int size;
+
         errno = 0;
         d = readdir(dir);
@@ -101 +116 @@
             break;
         }
-        if (d->d_name[0] == '.') continue;
+        if (d->d_name[0] == '.')
+            continue;
         fd = open(d->d_name, O_RDONLY | O_NDELAY);
         if (fd < 0) {
-            if ((errno == EISDIR) && env_dir) {
-                if (OPT_verbose)
+            if ((errno == EISDIR) && directory_name) {
+                if (option_mask32 & OPT_v)
                     bb_perror_msg("warning: %s/%s is a directory",
-                        directory_name, d->d_name);
-                continue;
-            } else
-                bb_perror_msg_and_die("open %s/%s",
                         directory_name, d->d_name);
-        }
-        if (fd >= 0) {
-            char buf[256];
-            char *tail;
-            int size;
-
-            size = safe_read(fd, buf, sizeof(buf)-1);
-            if (size < 0)
-                bb_perror_msg_and_die("read %s/%s",
-                        directory_name, d->d_name);
-            if (size == 0) {
-                unsetenv(d->d_name);
                 continue;
             }
-            buf[size] = '\n';
-            tail = memchr(buf, '\n', sizeof(buf));
-            /* skip trailing whitespace */;
-            while (1) {
-                if (tail[0]==' ') tail[0] = '\0';
-                if (tail[0]=='\t') tail[0] = '\0';
-                if (tail[0]=='\n') tail[0] = '\0';
-                if (tail == buf) break;
-                tail--;
-            }
-            xsetenv(d->d_name, buf);
-        }
+            bb_perror_msg_and_die("open %s/%s",
+                        directory_name, d->d_name);
+        }
+        size = full_read(fd, buf, sizeof(buf)-1);
+        close(fd);
+        if (size < 0)
+            bb_perror_msg_and_die("read %s/%s",
+                    directory_name, d->d_name);
+        if (size == 0) {
+            unsetenv(d->d_name);
+            continue;
+        }
+        buf[size] = '\n';
+        tail = strchr(buf, '\n');
+        /* skip trailing whitespace */
+        while (1) {
+            *tail = '\0';
+            tail--;
+            if (tail < buf || !isspace(*tail))
+                break;
+        }
+        xsetenv(d->d_name, buf);
     }
     closedir(dir);
-    if (fchdir(wdir) == -1) bb_perror_msg_and_die("fchdir");
+    if (fchdir(wdir) == -1)
+        bb_perror_msg_and_die("fchdir");
     close(wdir);
 }
@@ -148 +159 @@
     struct rlimit r;
 
-    if (getrlimit(what, &r) == -1) bb_perror_msg_and_die("getrlimit");
+    /* Never fails under Linux (except if you pass it bad arguments) */
+    getrlimit(what, &r);
     if ((l < 0) || (l > r.rlim_max))
         r.rlim_cur = r.rlim_max;
     else
         r.rlim_cur = l;
-    if (setrlimit(what, &r) == -1) bb_perror_msg_and_die("setrlimit");
+    if (setrlimit(what, &r) == -1)
+        bb_perror_msg_and_die("setrlimit");
 }
 
-static void slimit(void)
+int chpst_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int chpst_main(int argc UNUSED_PARAM, char **argv)
 {
-    if (limitd >= -1) {
+    struct bb_uidgid_t ugid;
+    char *set_user = set_user; /* for compiler */
+    char *env_user = env_user;
+    char *env_dir = env_dir;
+    char *root;
+    char *nicestr;
+    unsigned limita;
+    unsigned limitc;
+    unsigned limitd;
+    unsigned limitf;
+    unsigned limitl;
+    unsigned limitm;
+    unsigned limito;
+    unsigned limitp;
+    unsigned limitr;
+    unsigned limits;
+    unsigned limitt;
+    unsigned opt;
+
+    if ((ENABLE_CHPST && applet_name[0] == 'c')
+     || (ENABLE_SOFTLIMIT && applet_name[1] == 'o')
+    ) {
+        // FIXME: can we live with int-sized limits?
+        // can we live with 40000 days?
+        // if yes -> getopt converts strings to numbers for us
+        opt_complementary = "-1:a+:c+:d+:f+:l+:m+:o+:p+:r+:s+:t+";
+        opt = getopt32(argv, "+a:c:d:f:l:m:o:p:r:s:t:u:U:e:"
+            IF_CHPST("/:n:vP012"),
+            &limita, &limitc, &limitd, &limitf, &limitl,
+            &limitm, &limito, &limitp, &limitr, &limits, &limitt,
+            &set_user, &env_user, &env_dir
+            IF_CHPST(, &root, &nicestr));
+        argv += optind;
+        if (opt & OPT_m) { // -m means -asld
+            limita = limits = limitl = limitd = limitm;
+            opt |= (OPT_s | OPT_l | OPT_a | OPT_d);
+        }
+    } else {
+        option_mask32 = opt = 0;
+        argv++;
+        if (!*argv)
+            bb_show_usage();
+    }
+
+    // envdir?
+    if (ENABLE_ENVDIR && applet_name[3] == 'd') {
+        env_dir = *argv++;
+        opt |= OPT_e;
+    }
+
+    // setuidgid?
+    if (ENABLE_SETUIDGID && applet_name[1] == 'e') {
+        set_user = *argv++;
+        opt |= OPT_u;
+    }
+
+    // envuidgid?
+    if (ENABLE_ENVUIDGID && applet_name[0] == 'e' && applet_name[3] == 'u') {
+        env_user = *argv++;
+        opt |= OPT_U;
+    }
+
+    // we must have PROG [ARGS]
+    if (!*argv)
+        bb_show_usage();
+
+    // set limits
+    if (opt & OPT_d) {
 #ifdef RLIMIT_DATA
         limit(RLIMIT_DATA, limitd);
 #else
-        if (OPT_verbose) bb_error_msg("system does not support %s",
-                "RLIMIT_DATA");
-#endif
-    }
-    if (limits >= -1) {
+        if (opt & OPT_v)
+            bb_error_msg("system does not support RLIMIT_%s",
+                "DATA");
+#endif
+    }
+    if (opt & OPT_s) {
 #ifdef RLIMIT_STACK
         limit(RLIMIT_STACK, limits);
 #else
-        if (OPT_verbose) bb_error_msg("system does not support %s",
-                "RLIMIT_STACK");
-#endif
-    }
-    if (limitl >= -1) {
+        if (opt & OPT_v)
+            bb_error_msg("system does not support RLIMIT_%s",
+                "STACK");
+#endif
+    }
+    if (opt & OPT_l) {
 #ifdef RLIMIT_MEMLOCK
         limit(RLIMIT_MEMLOCK, limitl);
 #else
-        if (OPT_verbose) bb_error_msg("system does not support %s",
-                "RLIMIT_MEMLOCK");
-#endif
-    }
-    if (limita >= -1) {
+        if (opt & OPT_v)
+            bb_error_msg("system does not support RLIMIT_%s",
+                "MEMLOCK");
+#endif
+    }
+    if (opt & OPT_a) {
 #ifdef RLIMIT_VMEM
         limit(RLIMIT_VMEM, limita);
@@ -189 +273 @@
         limit(RLIMIT_AS, limita);
 #else
-        if (OPT_verbose)
-            bb_error_msg("system does not support %s",
-                "RLIMIT_VMEM");
-#endif
-#endif
-    }
-    if (limito >= -1) {
+        if (opt & OPT_v)
+            bb_error_msg("system does not support RLIMIT_%s",
+                "VMEM");
+#endif
+#endif
+    }
+    if (opt & OPT_o) {
 #ifdef RLIMIT_NOFILE
         limit(RLIMIT_NOFILE, limito);
@@ -202 +286 @@
         limit(RLIMIT_OFILE, limito);
 #else
-        if (OPT_verbose)
-            bb_error_msg("system does not support %s",
-                "RLIMIT_NOFILE");
-#endif
-#endif
-    }
-    if (limitp >= -1) {
+        if (opt & OPT_v)
+            bb_error_msg("system does not support RLIMIT_%s",
+                "NOFILE");
+#endif
+#endif
+    }
+    if (opt & OPT_p) {
 #ifdef RLIMIT_NPROC
         limit(RLIMIT_NPROC, limitp);
 #else
-        if (OPT_verbose) bb_error_msg("system does not support %s",
-                "RLIMIT_NPROC");
-#endif
-    }
-    if (limitf >= -1) {
+        if (opt & OPT_v)
+            bb_error_msg("system does not support RLIMIT_%s",
+                "NPROC");
+#endif
+    }
+    if (opt & OPT_f) {
 #ifdef RLIMIT_FSIZE
         limit(RLIMIT_FSIZE, limitf);
 #else
-        if (OPT_verbose) bb_error_msg("system does not support %s",
-                "RLIMIT_FSIZE");
-#endif
-    }
-    if (limitc >= -1) {
+        if (opt & OPT_v)
+            bb_error_msg("system does not support RLIMIT_%s",
+                "FSIZE");
+#endif
+    }
+    if (opt & OPT_c) {
 #ifdef RLIMIT_CORE
         limit(RLIMIT_CORE, limitc);
 #else
-        if (OPT_verbose) bb_error_msg("system does not support %s",
-                "RLIMIT_CORE");
-#endif
-    }
-    if (limitr >= -1) {
+        if (opt & OPT_v)
+            bb_error_msg("system does not support RLIMIT_%s",
+                "CORE");
+#endif
+    }
+    if (opt & OPT_r) {
 #ifdef RLIMIT_RSS
         limit(RLIMIT_RSS, limitr);
 #else
-        if (OPT_verbose) bb_error_msg("system does not support %s",
-                "RLIMIT_RSS");
-#endif
-    }
-    if (limitt >= -1) {
+        if (opt & OPT_v)
+            bb_error_msg("system does not support RLIMIT_%s",
+                "RSS");
+#endif
+    }
+    if (opt & OPT_t) {
 #ifdef RLIMIT_CPU
         limit(RLIMIT_CPU, limitt);
 #else
-        if (OPT_verbose) bb_error_msg("system does not support %s",
-                "RLIMIT_CPU");
-#endif
-    }
+        if (opt & OPT_v)
+            bb_error_msg("system does not support RLIMIT_%s",
+                "CPU");
+#endif
+    }
+
+    if (opt & OPT_P)
+        setsid();
+
+    if (opt & OPT_e)
+        edir(env_dir);
+
+    // FIXME: chrooted jail must have /etc/passwd if we move this after chroot!
+    // OTOH chroot fails for non-roots!
+    // SOLUTION: cache uid/gid before chroot, apply uid/gid after
+    if (opt & OPT_U) {
+        xget_uidgid(&ugid, env_user);
+        xsetenv("GID", utoa(ugid.gid));
+        xsetenv("UID", utoa(ugid.uid));
+    }
+
+    if (opt & OPT_u) {
+        xget_uidgid(&ugid, set_user);
+    }
+
+    if (opt & OPT_root) {
+        xchdir(root);
+        xchroot(".");
+    }
+
+    if (opt & OPT_u) {
+        if (setgroups(1, &ugid.gid) == -1)
+            bb_perror_msg_and_die("setgroups");
+        xsetgid(ugid.gid);
+        xsetuid(ugid.uid);
+    }
+
+    if (opt & OPT_n) {
+        errno = 0;
+        if (nice(xatoi(nicestr)) == -1)
+            bb_perror_msg_and_die("nice");
+    }
+
+    if (opt & OPT_0)
+        close(STDIN_FILENO);
+    if (opt & OPT_1)
+        close(STDOUT_FILENO);
+    if (opt & OPT_2)
+        close(STDERR_FILENO);
+
+    BB_EXECVP_or_die(argv);
 }
-
-/* argv[0] */
-static void setuidgid(int, char **);
-static void envuidgid(int, char **);
-static void envdir(int, char **);
-static void softlimit(int, char **);
-
-int chpst_main(int argc, char **argv);
-int chpst_main(int argc, char **argv)
-{
-    if (applet_name[3] == 'd') envdir(argc, argv);
-    if (applet_name[1] == 'o') softlimit(argc, argv);
-    if (applet_name[0] == 's') setuidgid(argc, argv);
-    if (applet_name[0] == 'e') envuidgid(argc, argv);
-    // otherwise we are chpst
-
-    {
-        char *m,*d,*o,*p,*f,*c,*r,*t,*n;
-        getopt32(argv, "+u:U:e:m:d:o:p:f:c:r:t:/:n:vP012",
-                &set_user,&env_user,&env_dir,
-                &m,&d,&o,&p,&f,&c,&r,&t,&root,&n);
-        // if (option_mask32 & 0x1) // -u
-        // if (option_mask32 & 0x2) // -U
-        // if (option_mask32 & 0x4) // -e
-        if (option_mask32 & 0x8) limits = limitl = limita = limitd = xatoul(m); // -m
-        if (option_mask32 & 0x10) limitd = xatoul(d); // -d
-        if (option_mask32 & 0x20) limito = xatoul(o); // -o
-        if (option_mask32 & 0x40) limitp = xatoul(p); // -p
-        if (option_mask32 & 0x80) limitf = xatoul(f); // -f
-        if (option_mask32 & 0x100) limitc = xatoul(c); // -c
-        if (option_mask32 & 0x200) limitr = xatoul(r); // -r
-        if (option_mask32 & 0x400) limitt = xatoul(t); // -t
-        // if (option_mask32 & 0x800) // -/
-        if (option_mask32 & 0x1000) nicelvl = xatoi(n); // -n
-        // The below consts should match #defines at top!
-        //if (option_mask32 & 0x2000) OPT_verbose = 1; // -v
-        //if (option_mask32 & 0x4000) OPT_pgrp = 1; // -P
-        //if (option_mask32 & 0x8000) OPT_nostdin = 1; // -0
-        //if (option_mask32 & 0x10000) OPT_nostdout = 1; // -1
-        //if (option_mask32 & 0x20000) OPT_nostderr = 1; // -2
-    }
-    argv += optind;
-    if (!argv || !*argv) bb_show_usage();
-
-    if (OPT_pgrp) setsid();
-    if (env_dir) edir(env_dir);
-    if (root) {
-        xchdir(root);
-        if (chroot(".") == -1)
-            bb_perror_msg_and_die("chroot");
-    }
-    slimit();
-    if (nicelvl) {
-        errno = 0;
-        if (nice(nicelvl) == -1)
-            bb_perror_msg_and_die("nice");
-    }
-    if (env_user) euidgid(env_user);
-    if (set_user) suidgid(set_user);
-    if (OPT_nostdin) close(0);
-    if (OPT_nostdout) close(1);
-    if (OPT_nostderr) close(2);
-    BB_EXECVP(argv[0], argv);
-    bb_perror_msg_and_die("exec %s", argv[0]);
-}
-
-static void setuidgid(int argc, char **argv)
-{
-    const char *account;
-
-    account = *++argv;
-    if (!account) bb_show_usage();
-    if (!*++argv) bb_show_usage();
-    suidgid((char*)account);
-    BB_EXECVP(argv[0], argv);
-    bb_perror_msg_and_die("exec %s", argv[0]);
-}
-
-static void envuidgid(int argc, char **argv)
-{
-    const char *account;
-
-    account = *++argv;
-    if (!account) bb_show_usage();
-    if (!*++argv) bb_show_usage();
-    euidgid((char*)account);
-    BB_EXECVP(argv[0], argv);
-    bb_perror_msg_and_die("exec %s", argv[0]);
-}
-
-static void envdir(int argc, char **argv)
-{
-    const char *dir;
-
-    dir = *++argv;
-    if (!dir) bb_show_usage();
-    if (!*++argv) bb_show_usage();
-    edir(dir);
-    BB_EXECVP(argv[0], argv);
-    bb_perror_msg_and_die("exec %s", argv[0]);
-}
-
-static void softlimit(int argc, char **argv)
-{
-    char *a,*c,*d,*f,*l,*m,*o,*p,*r,*s,*t;
-    getopt32(argv, "+a:c:d:f:l:m:o:p:r:s:t:",
-            &a,&c,&d,&f,&l,&m,&o,&p,&r,&s,&t);
-    if (option_mask32 & 0x001) limita = xatoul(a); // -a
-    if (option_mask32 & 0x002) limitc = xatoul(c); // -c
-    if (option_mask32 & 0x004) limitd = xatoul(d); // -d
-    if (option_mask32 & 0x008) limitf = xatoul(f); // -f
-    if (option_mask32 & 0x010) limitl = xatoul(l); // -l
-    if (option_mask32 & 0x020) limits = limitl = limita = limitd = xatoul(m); // -m
-    if (option_mask32 & 0x040) limito = xatoul(o); // -o
-    if (option_mask32 & 0x080) limitp = xatoul(p); // -p
-    if (option_mask32 & 0x100) limitr = xatoul(r); // -r
-    if (option_mask32 & 0x200) limits = xatoul(s); // -s
-    if (option_mask32 & 0x400) limitt = xatoul(t); // -t
-    argv += optind;
-    if (!argv[0]) bb_show_usage();
-    slimit();
-    BB_EXECVP(argv[0], argv);
-    bb_perror_msg_and_die("exec %s", argv[0]);
-}

branches/2.2.9/mindi-busybox/runit/runit_lib.h

@@ -26 +26 @@
 */
 
-extern unsigned byte_chr(char *s,unsigned n,int c);
-
-extern int coe(int);
-
-#define direntry struct dirent
-
-//struct tai {
-//  uint64_t x;
-//};
-//
-//#define tai_unix(t,u) ((void) ((t)->x = 0x400000000000000aULL + (uint64_t) (u)))
-//
-//#define TAI_PACK 8
-//extern void tai_unpack(const char *,struct tai *);
-//
-//extern void tai_uint(struct tai *,unsigned);
-//
-//struct taia {
-//  struct tai sec;
-//  unsigned long nano; /* 0...999999999 */
-//  unsigned long atto; /* 0...999999999 */
-//};
-//
-//extern void taia_now(struct taia *);
-//
-//extern void taia_add(struct taia *,const struct taia *,const struct taia *);
-//extern void taia_addsec(struct taia *,const struct taia *,int);
-//extern void taia_sub(struct taia *,const struct taia *,const struct taia *);
-//extern void taia_half(struct taia *,const struct taia *);
-//extern int taia_less(const struct taia *,const struct taia *);
-//
-//#define TAIA_PACK 16
-//extern void taia_pack(char *,const struct taia *);
-//
-//extern void taia_uint(struct taia *,unsigned);
-//
-//typedef struct pollfd iopause_fd;
-//#define IOPAUSE_READ POLLIN
-//#define IOPAUSE_WRITE POLLOUT
-//
-//extern void iopause(iopause_fd *,unsigned,struct taia *,struct taia *);
-
-extern int lock_ex(int);
-extern int lock_un(int);
-extern int lock_exnb(int);
-
-extern int open_read(const char *);
-extern int open_excl(const char *);
-extern int open_append(const char *);
-extern int open_trunc(const char *);
-extern int open_write(const char *);
-
-extern unsigned pmatch(const char *, const char *, unsigned);
-
-#define str_diff(s,t) strcmp((s), (t))
-#define str_equal(s,t) (!strcmp((s), (t)))
+PUSH_AND_SET_FUNCTION_VISIBILITY_TO_HIDDEN
 
 /*
@@ -87 +32 @@
  */
 typedef struct svstatus_t {
-    uint64_t time_be64 ATTRIBUTE_PACKED;
-    uint32_t time_nsec_be32 ATTRIBUTE_PACKED;
-    uint32_t pid_le32 ATTRIBUTE_PACKED;
+    uint64_t time_be64 PACKED;
+    uint32_t time_nsec_be32 PACKED;
+    uint32_t pid_le32 PACKED;
     uint8_t  paused;
-    uint8_t  want;
+    uint8_t  want; /* 'u' or 'd' */
     uint8_t  got_term;
     uint8_t  run_or_finish;
@@ -98 +43 @@
     char ERR_svstatus_must_be_20_bytes[sizeof(svstatus_t) == 20 ? 1 : -1];
 };
+
+POP_SAVED_FUNCTION_VISIBILITY

branches/2.2.9/mindi-busybox/runit/runsv.c

@@ -26 +26 @@
 */
 
-/* Busyboxed by Denis Vlasenko <vda.linux@googlemail.com> */
+/* Busyboxed by Denys Vlasenko <vda.linux@googlemail.com> */
 /* TODO: depends on runit_lib.c - review and reduce/eliminate */
 
@@ -61 +61 @@
 /* Compare possibly overflowing unsigned counters */
 #define LESS(a,b) ((int)((unsigned)(b) - (unsigned)(a)) > 0)
-
-static int selfpipe[2];
 
 /* state */
@@ -81 +79 @@
     smallint state;
     smallint ctrl;
-    smallint want;
+    smallint sd_want;
     smallint islog;
     struct timespec start;
@@ -87 +85 @@
     int fdcontrol;
     int fdcontrolwrite;
+    int wstat;
 };
 
-static struct svdir svd[2];
-static smallint sigterm;
-static smallint haslog;
-static smallint pidchanged = 1;
-static int logpipe[2];
-static char *dir;
+struct globals {
+    smallint haslog;
+    smallint sigterm;
+    smallint pidchanged;
+    struct fd_pair selfpipe;
+    struct fd_pair logpipe;
+    char *dir;
+    struct svdir svd[2];
+} FIX_ALIASING;
+#define G (*(struct globals*)&bb_common_bufsiz1)
+#define haslog       (G.haslog      )
+#define sigterm      (G.sigterm     )
+#define pidchanged   (G.pidchanged  )
+#define selfpipe     (G.selfpipe    )
+#define logpipe      (G.logpipe     )
+#define dir          (G.dir         )
+#define svd          (G.svd         )
+#define INIT_G() do { \
+    pidchanged = 1; \
+} while (0)
 
 static void fatal2_cannot(const char *m1, const char *m2)
@@ -116 +129 @@
 }
 
-static void s_child(int sig_no)
-{
-    write(selfpipe[1], "", 1);
-}
-
-static void s_term(int sig_no)
+static void s_child(int sig_no UNUSED_PARAM)
+{
+    write(selfpipe.wr, "", 1);
+}
+
+static void s_term(int sig_no UNUSED_PARAM)
 {
     sigterm = 1;
-    write(selfpipe[1], "", 1); /* XXX */
-}
-
-static char *add_str(char *p, const char *to_add)
+    write(selfpipe.wr, "", 1); /* XXX */
+}
+
+/* libbb candidate */
+static char *bb_stpcpy(char *p, const char *to_add)
 {
     while ((*p = *to_add) != '\0') {
@@ -138 +152 @@
 static int open_trunc_or_warn(const char *name)
 {
-    int fd = open_trunc(name);
+    /* Why O_NDELAY? */
+    int fd = open(name, O_WRONLY | O_NDELAY | O_TRUNC | O_CREAT, 0644);
     if (fd < 0)
         bb_perror_msg("%s: warning: cannot open %s",
                 dir, name);
     return fd;
-}
-
-static int rename_or_warn(const char *old, const char *new)
-{
-    if (rename(old, new) == -1) {
-        bb_perror_msg("%s: warning: cannot rename %s to %s",
-                dir, old, new);
-        return -1;
-    }
-    return 0;
 }
 
@@ -188 +193 @@
         switch (s->state) {
         case S_DOWN:
-            p = add_str(p, "down");
+            p = bb_stpcpy(p, "down");
             break;
         case S_RUN:
-            p = add_str(p, "run");
+            p = bb_stpcpy(p, "run");
             break;
         case S_FINISH:
-            p = add_str(p, "finish");
+            p = bb_stpcpy(p, "finish");
             break;
         }
-        if (s->ctrl & C_PAUSE) p = add_str(p, ", paused");
-        if (s->ctrl & C_TERM) p = add_str(p, ", got TERM");
+        if (s->ctrl & C_PAUSE)
+            p = bb_stpcpy(p, ", paused");
+        if (s->ctrl & C_TERM)
+            p = bb_stpcpy(p, ", got TERM");
         if (s->state != S_DOWN)
-            switch (s->want) {
+            switch (s->sd_want) {
             case W_DOWN:
-                p = add_str(p, ", want down");
+                p = bb_stpcpy(p, ", want down");
                 break;
             case W_EXIT:
-                p = add_str(p, ", want exit");
+                p = bb_stpcpy(p, ", want exit");
                 break;
             }
@@ -223 +230 @@
     if (s->ctrl & C_PAUSE)
         status.paused = 1;
-    if (s->want == W_UP)
+    if (s->sd_want == W_UP)
         status.want = 'u';
     else
@@ -246 +253 @@
 static unsigned custom(struct svdir *s, char c)
 {
-    int pid;
+    pid_t pid;
     int w;
     char a[10];
     struct stat st;
-    char *prog[2];
-
-    if (s->islog) return 0;
+
+    if (s->islog)
+        return 0;
     strcpy(a, "control/?");
-    a[8] = c;
+    a[8] = c; /* replace '?' */
     if (stat(a, &st) == 0) {
         if (st.st_mode & S_IXUSR) {
-            pid = fork();
+            pid = vfork();
             if (pid == -1) {
-                warn_cannot("fork for control/?");
+                warn_cannot("vfork for control/?");
                 return 0;
             }
-            if (!pid) {
-                if (haslog && dup2(logpipe[1], 1) == -1)
+            if (pid == 0) {
+                /* child */
+                if (haslog && dup2(logpipe.wr, 1) == -1)
                     warn_cannot("setup stdout for control/?");
-                prog[0] = a;
-                prog[1] = NULL;
-                execve(a, prog, environ);
+                execl(a, a, (char *) NULL);
                 fatal_cannot("run control/?");
             }
-            while (wait_pid(&w, pid) == -1) {
-                if (errno == EINTR) continue;
+            /* parent */
+            if (safe_waitpid(pid, &w, 0) == -1) {
                 warn_cannot("wait for child control/?");
                 return 0;
             }
-            return !wait_exitcode(w);
+            return WEXITSTATUS(w) == 0;
         }
     } else {
@@ -291 +297 @@
         update_status(s);
     }
-    if (s->want == W_DOWN) {
+    if (s->sd_want == W_DOWN) {
         kill(s->pid, SIGCONT);
         custom(s, 'd');
         return;
     }
-    if (s->want == W_EXIT) {
+    if (s->sd_want == W_EXIT) {
         kill(s->pid, SIGCONT);
         custom(s, 'x');
@@ -305 +311 @@
 {
     int p;
-    char *run[2];
-
-    if (s->state == S_FINISH)
-        run[0] = (char*)"./finish";
-    else {
-        run[0] = (char*)"./run";
+    const char *arg[4];
+    char exitcode[sizeof(int)*3 + 2];
+
+    if (s->state == S_FINISH) {
+/* Two arguments are given to ./finish. The first one is ./run exit code,
+ * or -1 if ./run didnt exit normally. The second one is
+ * the least significant byte of the exit status as determined by waitpid;
+ * for instance it is 0 if ./run exited normally, and the signal number
+ * if ./run was terminated by a signal. If runsv cannot start ./run
+ * for some reason, the exit code is 111 and the status is 0.
+ */
+        arg[0] = "./finish";
+        arg[1] = "-1";
+        if (WIFEXITED(s->wstat)) {
+            *utoa_to_buf(WEXITSTATUS(s->wstat), exitcode, sizeof(exitcode)) = '\0';
+            arg[1] = exitcode;
+        }
+        //arg[2] = "0";
+        //if (WIFSIGNALED(s->wstat)) {
+            arg[2] = utoa(WTERMSIG(s->wstat));
+        //}
+        arg[3] = NULL;
+    } else {
+        arg[0] = "./run";
+        arg[1] = NULL;
         custom(s, 'u');
     }
-    run[1] = NULL;
 
     if (s->pid != 0)
         stopservice(s); /* should never happen */
-    while ((p = fork()) == -1) {
-        warn_cannot("fork, sleeping");
+    while ((p = vfork()) == -1) {
+        warn_cannot("vfork, sleeping");
         sleep(5);
     }
@@ -324 +348 @@
         /* child */
         if (haslog) {
+            /* NB: bug alert! right order is close, then dup2 */
             if (s->islog) {
-                xdup2(logpipe[0], 0);
-                close(logpipe[1]);
                 xchdir("./log");
+                close(logpipe.wr);
+                xdup2(logpipe.rd, 0);
             } else {
-                xdup2(logpipe[1], 1);
-                close(logpipe[0]);
-            }
-        }
-        signal(SIGCHLD, SIG_DFL);
-        signal(SIGTERM, SIG_DFL);
+                close(logpipe.rd);
+                xdup2(logpipe.wr, 1);
+            }
+        }
+        /* Non-ignored signals revert to SIG_DFL on exec anyway */
+        /*bb_signals(0
+            + (1 << SIGCHLD)
+            + (1 << SIGTERM)
+            , SIG_DFL);*/
         sig_unblock(SIGCHLD);
         sig_unblock(SIGTERM);
-        execvp(*run, run);
-        fatal2_cannot(s->islog ? "start log/" : "start ", *run);
-    }
+        execv(arg[0], (char**) arg);
+        fatal2_cannot(s->islog ? "start log/" : "start ", arg[0]);
+    }
+    /* parent */
     if (s->state != S_FINISH) {
         gettimeofday_ns(&s->start);
@@ -356 +385 @@
     switch (c) {
     case 'd': /* down */
-        s->want = W_DOWN;
+        s->sd_want = W_DOWN;
         update_status(s);
         if (s->pid && s->state != S_FINISH)
@@ -362 +391 @@
         break;
     case 'u': /* up */
-        s->want = W_UP;
+        s->sd_want = W_UP;
         update_status(s);
         if (s->pid == 0)
@@ -370 +399 @@
         if (s->islog)
             break;
-        s->want = W_EXIT;
+        s->sd_want = W_EXIT;
         update_status(s);
         /* FALLTHROUGH */
@@ -391 +420 @@
         if (s->pid && !custom(s, c))
             kill(s->pid, SIGCONT);
-        if (s->ctrl & C_PAUSE)
-            s->ctrl &= ~C_PAUSE;
+        s->ctrl &= ~C_PAUSE;
         update_status(s);
         break;
     case 'o': /* once */
-        s->want = W_DOWN;
+        s->sd_want = W_DOWN;
         update_status(s);
         if (!s->pid)
@@ -427 +455 @@
 }
 
-int runsv_main(int argc, char **argv);
-int runsv_main(int argc, char **argv)
+int runsv_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int runsv_main(int argc UNUSED_PARAM, char **argv)
 {
     struct stat s;
@@ -435 +463 @@
     char buf[256];
 
-    if (!argv[1] || argv[2])
-        bb_show_usage();
-    dir = argv[1];
-
-    xpipe(selfpipe);
-    coe(selfpipe[0]);
-    coe(selfpipe[1]);
-    ndelay_on(selfpipe[0]);
-    ndelay_on(selfpipe[1]);
+    INIT_G();
+
+    dir = single_argv(argv);
+
+    xpiped_pair(selfpipe);
+    close_on_exec_on(selfpipe.rd);
+    close_on_exec_on(selfpipe.wr);
+    ndelay_on(selfpipe.rd);
+    ndelay_on(selfpipe.wr);
 
     sig_block(SIGCHLD);
-    sig_catch(SIGCHLD, s_child);
+    bb_signals_recursive_norestart(1 << SIGCHLD, s_child);
     sig_block(SIGTERM);
-    sig_catch(SIGTERM, s_term);
+    bb_signals_recursive_norestart(1 << SIGTERM, s_term);
 
     xchdir(dir);
@@ -454 +482 @@
     if (S_DOWN) svd[0].state = S_DOWN; /* otherwise already 0 (bss) */
     if (C_NOOP) svd[0].ctrl = C_NOOP;
-    if (W_UP) svd[0].want = W_UP;
+    if (W_UP) svd[0].sd_want = W_UP;
     /* bss: svd[0].islog = 0; */
     /* bss: svd[1].pid = 0; */
     gettimeofday_ns(&svd[0].start);
-    if (stat("down", &s) != -1) svd[0].want = W_DOWN;
+    if (stat("down", &s) != -1)
+        svd[0].sd_want = W_DOWN;
 
     if (stat("log", &s) == -1) {
@@ -471 +500 @@
             svd[1].state = S_DOWN;
             svd[1].ctrl = C_NOOP;
-            svd[1].want = W_UP;
+            svd[1].sd_want = W_UP;
             svd[1].islog = 1;
             gettimeofday_ns(&svd[1].start);
             if (stat("log/down", &s) != -1)
-                svd[1].want = W_DOWN;
-            xpipe(logpipe);
-            coe(logpipe[0]);
-            coe(logpipe[1]);
+                svd[1].sd_want = W_DOWN;
+            xpiped_pair(logpipe);
+            close_on_exec_on(logpipe.rd);
+            close_on_exec_on(logpipe.wr);
         }
     }
@@ -496 +525 @@
     svd[0].fdlock = xopen3("log/supervise/lock"+4,
             O_WRONLY|O_NDELAY|O_APPEND|O_CREAT, 0600);
-    if (lock_exnb(svd[0].fdlock) == -1)
+    if (flock(svd[0].fdlock, LOCK_EX | LOCK_NB) == -1)
         fatal_cannot("lock supervise/lock");
-    coe(svd[0].fdlock);
+    close_on_exec_on(svd[0].fdlock);
     if (haslog) {
         if (mkdir("log/supervise", 0700) == -1) {
@@ -520 +549 @@
         svd[1].fdlock = xopen3("log/supervise/lock",
                 O_WRONLY|O_NDELAY|O_APPEND|O_CREAT, 0600);
-        if (lock_ex(svd[1].fdlock) == -1)
+        if (flock(svd[1].fdlock, LOCK_EX) == -1)
             fatal_cannot("lock log/supervise/lock");
-        coe(svd[1].fdlock);
+        close_on_exec_on(svd[1].fdlock);
     }
 
     mkfifo("log/supervise/control"+4, 0600);
     svd[0].fdcontrol = xopen("log/supervise/control"+4, O_RDONLY|O_NDELAY);
-    coe(svd[0].fdcontrol);
+    close_on_exec_on(svd[0].fdcontrol);
     svd[0].fdcontrolwrite = xopen("log/supervise/control"+4, O_WRONLY|O_NDELAY);
-    coe(svd[0].fdcontrolwrite);
+    close_on_exec_on(svd[0].fdcontrolwrite);
     update_status(&svd[0]);
     if (haslog) {
         mkfifo("log/supervise/control", 0600);
         svd[1].fdcontrol = xopen("log/supervise/control", O_RDONLY|O_NDELAY);
-        coe(svd[1].fdcontrol);
+        close_on_exec_on(svd[1].fdcontrol);
         svd[1].fdcontrolwrite = xopen("log/supervise/control", O_WRONLY|O_NDELAY);
-        coe(svd[1].fdcontrolwrite);
+        close_on_exec_on(svd[1].fdcontrolwrite);
         update_status(&svd[1]);
     }
     mkfifo("log/supervise/ok"+4, 0600);
     fd = xopen("log/supervise/ok"+4, O_RDONLY|O_NDELAY);
-    coe(fd);
+    close_on_exec_on(fd);
     if (haslog) {
         mkfifo("log/supervise/ok", 0600);
         fd = xopen("log/supervise/ok", O_RDONLY|O_NDELAY);
-        coe(fd);
+        close_on_exec_on(fd);
     }
     for (;;) {
@@ -553 +582 @@
 
         if (haslog)
-            if (!svd[1].pid && svd[1].want == W_UP)
+            if (!svd[1].pid && svd[1].sd_want == W_UP)
                 startservice(&svd[1]);
         if (!svd[0].pid)
-            if (svd[0].want == W_UP || svd[0].state == S_FINISH)
+            if (svd[0].sd_want == W_UP || svd[0].state == S_FINISH)
                 startservice(&svd[0]);
 
-        x[0].fd = selfpipe[0];
+        x[0].fd = selfpipe.rd;
         x[0].events = POLLIN;
         x[1].fd = svd[0].fdcontrol;
@@ -572 +601 @@
         sig_block(SIGCHLD);
 
-        while (read(selfpipe[0], &ch, 1) == 1)
+        while (read(selfpipe.rd, &ch, 1) == 1)
             continue;
 
         for (;;) {
-            int child;
+            pid_t child;
             int wstat;
 
-            child = wait_nohang(&wstat);
+            child = wait_any_nohang(&wstat);
             if (!child)
                 break;
@@ -585 +614 @@
                 break;
             if (child == svd[0].pid) {
+                svd[0].wstat = wstat;
                 svd[0].pid = 0;
                 pidchanged = 1;
-                svd[0].ctrl &=~ C_TERM;
+                svd[0].ctrl &= ~C_TERM;
                 if (svd[0].state != S_FINISH) {
-                    fd = open_read("finish");
+                    fd = open("finish", O_RDONLY|O_NDELAY);
                     if (fd != -1) {
                         close(fd);
@@ -606 +636 @@
             if (haslog) {
                 if (child == svd[1].pid) {
+                    svd[0].wstat = wstat;
                     svd[1].pid = 0;
                     pidchanged = 1;
@@ -617 +648 @@
                 }
             }
-        }
+        } /* for (;;) */
         if (read(svd[0].fdcontrol, &ch, 1) == 1)
             ctrl(&svd[0], ch);
@@ -629 +660 @@
         }
 
-        if (svd[0].want == W_EXIT && svd[0].state == S_DOWN) {
+        if (svd[0].sd_want == W_EXIT && svd[0].state == S_DOWN) {
             if (svd[1].pid == 0)
-                _exit(0);
-            if (svd[1].want != W_EXIT) {
-                svd[1].want = W_EXIT;
+                _exit(EXIT_SUCCESS);
+            if (svd[1].sd_want != W_EXIT) {
+                svd[1].sd_want = W_EXIT;
                 /* stopservice(&svd[1]); */
                 update_status(&svd[1]);
-                close(logpipe[1]);
-                close(logpipe[0]);
-            }
-        }
-    }
+                close(logpipe.wr);
+                close(logpipe.rd);
+            }
+        }
+    } /* for (;;) */
     /* not reached */
     return 0;

branches/2.2.9/mindi-busybox/runit/runsvdir.c

@@ -26 +26 @@
 */
 
-/* Busyboxed by Denis Vlasenko <vda.linux@googlemail.com> */
+/* Busyboxed by Denys Vlasenko <vda.linux@googlemail.com> */
 /* TODO: depends on runit_lib.c - review and reduce/eliminate */
 
@@ -36 +36 @@
 #define MAXSERVICES 1000
 
+/* Should be not needed - all dirs are on same FS, right? */
+#define CHECK_DEVNO_TOO 0
+
 struct service {
+#if CHECK_DEVNO_TOO
     dev_t dev;
+#endif
     ino_t ino;
     pid_t pid;
@@ -43 +48 @@
 };
 
-struct service *sv;
-static char *svdir;
-static int svnum;
-static char *rplog;
-static int rploglen;
-static int logpipe[2];
-static struct pollfd pfd[1];
-static unsigned stamplog;
-static smallint check = 1;
-static smallint exitsoon;
-static smallint set_pgrp;
+struct globals {
+    struct service *sv;
+    char *svdir;
+    int svnum;
+#if ENABLE_FEATURE_RUNSVDIR_LOG
+    char *rplog;
+    int rploglen;
+    struct fd_pair logpipe;
+    struct pollfd pfd[1];
+    unsigned stamplog;
+#endif
+} FIX_ALIASING;
+#define G (*(struct globals*)&bb_common_bufsiz1)
+#define sv          (G.sv          )
+#define svdir       (G.svdir       )
+#define svnum       (G.svnum       )
+#define rplog       (G.rplog       )
+#define rploglen    (G.rploglen    )
+#define logpipe     (G.logpipe     )
+#define pfd         (G.pfd         )
+#define stamplog    (G.stamplog    )
+#define INIT_G() do { \
+} while (0)
 
 static void fatal2_cannot(const char *m1, const char *m2)
 {
-    bb_perror_msg_and_die("%s: fatal: cannot %s%s", svdir, m1, m2);
+    bb_perror_msg_and_die("%s: fatal: can't %s%s", svdir, m1, m2);
     /* was exiting 100 */
 }
@@ -66 +83 @@
 static void warn2_cannot(const char *m1, const char *m2)
 {
-    warn3x("cannot ", m1, m2);
-}
+    warn3x("can't ", m1, m2);
+}
+#if ENABLE_FEATURE_RUNSVDIR_LOG
 static void warnx(const char *m1)
 {
     warn3x(m1, "", "");
 }
-
-static void s_term(int sig_no)
-{
-    exitsoon = 1;
-}
-static void s_hangup(int sig_no)
-{
-    exitsoon = 2;
-}
-
-static void runsv(int no, const char *name)
+#endif
+
+/* inlining + vfork -> bigger code */
+static NOINLINE pid_t runsv(const char *name)
 {
     pid_t pid;
-    char *prog[3];
-
-    prog[0] = (char*)"runsv";
-    prog[1] = (char*)name;
-    prog[2] = NULL;
+
+    /* If we got signaled, stop spawning children at once! */
+    if (bb_got_signal)
+        return 0;
 
     pid = vfork();
-
     if (pid == -1) {
         warn2_cannot("vfork", "");
-        return;
+        return 0;
     }
     if (pid == 0) {
         /* child */
-        if (set_pgrp)
+        if (option_mask32 & 1) /* -P option? */
             setsid();
-        signal(SIGHUP, SIG_DFL);
-        signal(SIGTERM, SIG_DFL);
-        execvp(prog[0], prog);
+/* man execv:
+ * "Signals set to be caught by the calling process image
+ *  shall be set to the default action in the new process image."
+ * Therefore, we do not need this: */
+#if 0
+        bb_signals(0
+            | (1 << SIGHUP)
+            | (1 << SIGTERM)
+            , SIG_DFL);
+#endif
+        execlp("runsv", "runsv", name, (char *) NULL);
         fatal2_cannot("start runsv ", name);
     }
-    sv[no].pid = pid;
-}
-
-static void runsvdir(void)
+    return pid;
+}
+
+/* gcc 4.3.0 does better with NOINLINE */
+static NOINLINE int do_rescan(void)
 {
     DIR *dir;
-    direntry *d;
+    struct dirent *d;
     int i;
     struct stat s;
+    int need_rescan = 0;
 
     dir = opendir(".");
     if (!dir) {
         warn2_cannot("open directory ", svdir);
-        return;
+        return 1; /* need to rescan again soon */
     }
     for (i = 0; i < svnum; i++)
         sv[i].isgone = 1;
-    errno = 0;
-    while ((d = readdir(dir))) {
+
+    while (1) {
+        errno = 0;
+        d = readdir(dir);
+        if (!d)
+            break;
         if (d->d_name[0] == '.')
             continue;
         if (stat(d->d_name, &s) == -1) {
             warn2_cannot("stat ", d->d_name);
-            errno = 0;
             continue;
         }
         if (!S_ISDIR(s.st_mode))
             continue;
+        /* Do we have this service listed already? */
         for (i = 0; i < svnum; i++) {
-            if ((sv[i].ino == s.st_ino) && (sv[i].dev == s.st_dev)) {
-                sv[i].isgone = 0;
-                if (!sv[i].pid)
-                    runsv(i, d->d_name);
-                break;
-            }
-        }
-        if (i == svnum) {
-            /* new service */
+            if ((sv[i].ino == s.st_ino)
+#if CHECK_DEVNO_TOO
+             && (sv[i].dev == s.st_dev)
+#endif
+            ) {
+                if (sv[i].pid == 0) /* restart if it has died */
+                    goto run_ith_sv;
+                sv[i].isgone = 0; /* "we still see you" */
+                goto next_dentry;
+            }
+        }
+        { /* Not found, make new service */
             struct service *svnew = realloc(sv, (i+1) * sizeof(*sv));
             if (!svnew) {
-                warn3x("cannot start runsv ", d->d_name,
-                        " too many services");
+                warn2_cannot("start runsv ", d->d_name);
+                need_rescan = 1;
                 continue;
             }
             sv = svnew;
             svnum++;
-            memset(&sv[i], 0, sizeof(sv[i]));
+#if CHECK_DEVNO_TOO
+            sv[i].dev = s.st_dev;
+#endif
             sv[i].ino = s.st_ino;
-            sv[i].dev = s.st_dev;
-            /*sv[i].pid = 0;*/
-            /*sv[i].isgone = 0;*/
-            runsv(i, d->d_name);
-            check = 1;
-        }
-    }
-    if (errno) {
+ run_ith_sv:
+            sv[i].pid = runsv(d->d_name);
+            sv[i].isgone = 0;
+        }
+ next_dentry: ;
+    }
+    i = errno;
+    closedir(dir);
+    if (i) { /* readdir failed */
         warn2_cannot("read directory ", svdir);
-        closedir(dir);
-        check = 1;
-        return;
-    }
-    closedir(dir);
-
-    /* SIGTERM removed runsv's */
+        return 1; /* need to rescan again soon */
+    }
+
+    /* Send SIGTERM to runsv whose directories
+     * were no longer found (-> must have been removed) */
     for (i = 0; i < svnum; i++) {
         if (!sv[i].isgone)
@@ -175 +202 @@
         if (sv[i].pid)
             kill(sv[i].pid, SIGTERM);
-        sv[i] = sv[--svnum];
-        check = 1;
-    }
-}
-
-static int setup_log(void)
-{
-    rploglen = strlen(rplog);
-    if (rploglen < 7) {
-        warnx("log must have at least seven characters");
-        return 0;
-    }
-    if (pipe(logpipe)) {
-        warnx("cannot create pipe for log");
-        return -1;
-    }
-    coe(logpipe[1]);
-    coe(logpipe[0]);
-    ndelay_on(logpipe[0]);
-    ndelay_on(logpipe[1]);
-    if (dup2(logpipe[1], 2) == -1) {
-        warnx("cannot set filedescriptor for log");
-        return -1;
-    }
-    pfd[0].fd = logpipe[0];
-    pfd[0].events = POLLIN;
-    stamplog = monotonic_sec();
-    return 1;
-}
-
-int runsvdir_main(int argc, char **argv);
-int runsvdir_main(int argc, char **argv)
+        svnum--;
+        sv[i] = sv[svnum];
+        i--; /* so that we don't skip new sv[i] (bug was here!) */
+    }
+    return need_rescan;
+}
+
+int runsvdir_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int runsvdir_main(int argc UNUSED_PARAM, char **argv)
 {
     struct stat s;
@@ -214 +218 @@
     int wstat;
     int curdir;
-    int pid;
+    pid_t pid;
     unsigned deadline;
     unsigned now;
     unsigned stampcheck;
-    char ch;
     int i;
-
-    argv++;
-    if (!*argv)
-        bb_show_usage();
-    if (argv[0][0] == '-') {
-        switch (argv[0][1]) {
-        case 'P': set_pgrp = 1;
-        case '-': ++argv;
-        }
-        if (!*argv)
-            bb_show_usage();
-    }
-
-    sig_catch(SIGTERM, s_term);
-    sig_catch(SIGHUP, s_hangup);
+    int need_rescan = 1;
+    char *opt_s_argv[3];
+
+    INIT_G();
+
+    opt_complementary = "-1";
+    opt_s_argv[0] = NULL;
+    opt_s_argv[2] = NULL;
+    getopt32(argv, "Ps:", &opt_s_argv[0]);
+    argv += optind;
+
+    bb_signals(0
+        | (1 << SIGTERM)
+        | (1 << SIGHUP)
+        /* For busybox's init, SIGTERM == reboot,
+         * SIGUSR1 == halt
+         * SIGUSR2 == poweroff
+         * so we need to intercept SIGUSRn too.
+         * Note that we do not implement actual reboot
+         * (killall(TERM) + umount, etc), we just pause
+         * respawing and avoid exiting (-> making kernel oops).
+         * The user is responsible for the rest. */
+        | (getpid() == 1 ? ((1 << SIGUSR1) | (1 << SIGUSR2)) : 0)
+        , record_signo);
     svdir = *argv++;
-    if (argv && *argv) {
+
+#if ENABLE_FEATURE_RUNSVDIR_LOG
+    /* setup log */
+    if (*argv) {
         rplog = *argv;
-        if (setup_log() != 1) {
-            rplog = 0;
-            warnx("log service disabled");
-        }
-    }
-    curdir = open_read(".");
+        rploglen = strlen(rplog);
+        if (rploglen < 7) {
+            warnx("log must have at least seven characters");
+        } else if (piped_pair(logpipe)) {
+            warnx("can't create pipe for log");
+        } else {
+            close_on_exec_on(logpipe.rd);
+            close_on_exec_on(logpipe.wr);
+            ndelay_on(logpipe.rd);
+            ndelay_on(logpipe.wr);
+            if (dup2(logpipe.wr, 2) == -1) {
+                warnx("can't set filedescriptor for log");
+            } else {
+                pfd[0].fd = logpipe.rd;
+                pfd[0].events = POLLIN;
+                stamplog = monotonic_sec();
+                goto run;
+            }
+        }
+        rplog = NULL;
+        warnx("log service disabled");
+    }
+ run:
+#endif
+    curdir = open(".", O_RDONLY|O_NDELAY);
     if (curdir == -1)
         fatal2_cannot("open current directory", "");
-    coe(curdir);
+    close_on_exec_on(curdir);
 
     stampcheck = monotonic_sec();
@@ -253 +287 @@
         /* collect children */
         for (;;) {
-            pid = wait_nohang(&wstat);
+            pid = wait_any_nohang(&wstat);
             if (pid <= 0)
                 break;
             for (i = 0; i < svnum; i++) {
                 if (pid == sv[i].pid) {
-                    /* runsv has gone */
+                    /* runsv has died */
                     sv[i].pid = 0;
-                    check = 1;
-                    break;
+                    need_rescan = 1;
                 }
             }
@@ -272 +305 @@
 
             if (stat(svdir, &s) != -1) {
-                if (check || s.st_mtime != last_mtime
+                if (need_rescan || s.st_mtime != last_mtime
                  || s.st_ino != last_ino || s.st_dev != last_dev
                 ) {
@@ -280 +313 @@
                         last_dev = s.st_dev;
                         last_ino = s.st_ino;
-                        check = 0;
-                        //if (now <= mtime)
-                        //  sleep(1);
-                        runsvdir();
+                        /* if the svdir changed this very second, wait until the
+                         * next second, because we won't be able to detect more
+                         * changes within this second */
+                        while (time(NULL) == last_mtime)
+                            usleep(100000);
+                        need_rescan = do_rescan();
                         while (fchdir(curdir) == -1) {
                             warn2_cannot("change directory, pausing", "");
                             sleep(5);
                         }
-                    } else
+                    } else {
                         warn2_cannot("change directory to ", svdir);
+                    }
                 }
-            } else
+            } else {
                 warn2_cannot("stat ", svdir);
-        }
-
+            }
+        }
+
+#if ENABLE_FEATURE_RUNSVDIR_LOG
         if (rplog) {
             if ((int)(now - stamplog) >= 0) {
-                write(logpipe[1], ".", 1);
+                write(logpipe.wr, ".", 1);
                 stamplog = now + 900;
             }
         }
-
         pfd[0].revents = 0;
+#endif
+        deadline = (need_rescan ? 1 : 5);
         sig_block(SIGCHLD);
-        deadline = (check ? 1 : 5);
+#if ENABLE_FEATURE_RUNSVDIR_LOG
         if (rplog)
             poll(pfd, 1, deadline*1000);
         else
+#endif
             sleep(deadline);
         sig_unblock(SIGCHLD);
 
+#if ENABLE_FEATURE_RUNSVDIR_LOG
         if (pfd[0].revents & POLLIN) {
-            while (read(logpipe[0], &ch, 1) > 0) {
-                if (ch) {
-                    for (i = 6; i < rploglen; i++)
-                        rplog[i-1] = rplog[i];
-                    rplog[rploglen-1] = ch;
-                }
-            }
-        }
-
-        switch (exitsoon) {
-        case 1:
-            _exit(0);
-        case 2:
+            char ch;
+            while (read(logpipe.rd, &ch, 1) > 0) {
+                if (ch < ' ')
+                    ch = ' ';
+                for (i = 6; i < rploglen; i++)
+                    rplog[i-1] = rplog[i];
+                rplog[rploglen-1] = ch;
+            }
+        }
+#endif
+        if (!bb_got_signal)
+            continue;
+
+        /* -s SCRIPT: useful if we are init.
+         * In this case typically script never returns,
+         * it halts/powers off/reboots the system. */
+        if (opt_s_argv[0]) {
+            /* Single parameter: signal# */
+            opt_s_argv[1] = utoa(bb_got_signal);
+            pid = spawn(opt_s_argv);
+            if (pid > 0) {
+                /* Remembering to wait for _any_ children,
+                 * not just pid */
+                while (wait(NULL) != pid)
+                    continue;
+            }
+        }
+
+        if (bb_got_signal == SIGHUP) {
             for (i = 0; i < svnum; i++)
                 if (sv[i].pid)
                     kill(sv[i].pid, SIGTERM);
-            _exit(111);
-        }
-    }
-    /* not reached */
-    return 0;
-}
+        }
+        /* SIGHUP or SIGTERM (or SIGUSRn if we are init) */
+        /* Exit unless we are init */
+        if (getpid() != 1)
+            return (SIGHUP == bb_got_signal) ? 111 : EXIT_SUCCESS;
+
+        /* init continues to monitor services forever */
+        bb_got_signal = 0;
+    } /* for (;;) */
+}

branches/2.2.9/mindi-busybox/runit/sv.c

@@ -151 +151 @@
 */
 
-/* Busyboxed by Denis Vlasenko <vda.linux@googlemail.com> */
+/* Busyboxed by Denys Vlasenko <vda.linux@googlemail.com> */
 /* TODO: depends on runit_lib.c - review and reduce/eliminate */
 
@@ -159 +159 @@
 #include "runit_lib.h"
 
-static const char *acts;
-static char **service;
-static unsigned rc;
+struct globals {
+    const char *acts;
+    char **service;
+    unsigned rc;
 /* "Bernstein" time format: unix + 0x400000000000000aULL */
-static uint64_t tstart, tnow;
-svstatus_t svstatus;
-
-
-static void fatal_cannot(const char *m1) ATTRIBUTE_NORETURN;
+    uint64_t tstart, tnow;
+    svstatus_t svstatus;
+} FIX_ALIASING;
+#define G (*(struct globals*)&bb_common_bufsiz1)
+#define acts         (G.acts        )
+#define service      (G.service     )
+#define rc           (G.rc          )
+#define tstart       (G.tstart      )
+#define tnow         (G.tnow        )
+#define svstatus     (G.svstatus    )
+#define INIT_G() do { } while (0)
+
+
+#define str_equal(s,t) (!strcmp((s), (t)))
+
+
+static void fatal_cannot(const char *m1) NORETURN;
 static void fatal_cannot(const char *m1)
 {
-    bb_perror_msg("fatal: cannot %s", m1);
+    bb_perror_msg("fatal: can't %s", m1);
     _exit(151);
 }
@@ -180 +193 @@
         printf(": %s", strerror(errno));
     }
-    puts(""); /* will also flush the output */
+    bb_putchar('\n'); /* will also flush the output */
 }
 
@@ -212 +225 @@
     int fd, r;
 
-    fd = open_write("supervise/ok");
+    fd = open("supervise/ok", O_WRONLY|O_NDELAY);
     if (fd == -1) {
         if (errno == ENODEV) {
@@ -219 +232 @@
             return 0;
         }
-        warn("cannot open supervise/ok");
+        warn("can't open supervise/ok");
         return -1;
     }
     close(fd);
-    fd = open_read("supervise/status");
+    fd = open("supervise/status", O_RDONLY|O_NDELAY);
     if (fd == -1) {
-        warn("cannot open supervise/status");
+        warn("can't open supervise/status");
         return -1;
     }
@@ -234 +247 @@
         break;
     case -1:
-        warn("cannot read supervise/status");
+        warn("can't read supervise/status");
         return -1;
     default:
         errno = 0;
-        warn("cannot read supervise/status: bad format");
+        warn("can't read supervise/status: bad format");
         return -1;
     }
@@ -254 +267 @@
     if (stat("down", &s) == -1) {
         if (errno != ENOENT) {
-            bb_perror_msg(WARN"cannot stat %s/down", *service);
+            bb_perror_msg(WARN"can't stat %s/down", *service);
             return 0;
         }
@@ -284 +297 @@
 }
 
-static int status(const char *unused)
+static int status(const char *unused UNUSED_PARAM)
 {
     int r;
 
-    r = svstatus_get();
-    switch (r) { case -1: case 0: return 0; }
+    if (svstatus_get() <= 0)
+        return 0;
 
     r = svstatus_print(*service);
     if (chdir("log") == -1) {
         if (errno != ENOENT) {
-            printf("; log: "WARN"cannot change to log service directory: %s",
+            printf("; log: "WARN"can't change to log service directory: %s",
                     strerror(errno));
         }
@@ -301 +314 @@
         svstatus_print("log");
     }
-    puts(""); /* will also flush the output */
+    bb_putchar('\n'); /* will also flush the output */
     return r;
 }
@@ -313 +326 @@
     if (stat("check", &s) == -1) {
         if (errno == ENOENT) return 1;
-        bb_perror_msg(WARN"cannot stat %s/check", *service);
+        bb_perror_msg(WARN"can't stat %s/check", *service);
         return 0;
     }
@@ -321 +334 @@
     pid = spawn(prog);
     if (pid <= 0) {
-        bb_perror_msg(WARN"cannot %s child %s/check", "run", *service);
+        bb_perror_msg(WARN"can't %s child %s/check", "run", *service);
         return 0;
     }
-    while (wait_pid(&w, pid) == -1) {
-        if (errno == EINTR) continue;
-        bb_perror_msg(WARN"cannot %s child %s/check", "wait for", *service);
+    while (safe_waitpid(pid, &w, 0) == -1) {
+        bb_perror_msg(WARN"can't %s child %s/check", "wait for", *service);
         return 0;
     }
-    return !wait_exitcode(w);
+    return WEXITSTATUS(w) == 0;
 }
 
@@ -335 +347 @@
 {
     int r;
-    unsigned pid;
+    unsigned pid_le32;
     uint64_t timestamp;
 
@@ -346 +358 @@
         return -1;
     }
-    pid = SWAP_LE32(svstatus.pid_le32);
+    pid_le32 = svstatus.pid_le32;
     switch (*a) {
     case 'x':
         return 0;
     case 'u':
-        if (!pid || svstatus.run_or_finish != 1) return 0;
+        if (!pid_le32 || svstatus.run_or_finish != 1) return 0;
         if (!checkscript()) return 0;
         break;
     case 'd':
-        if (pid) return 0;
+        if (pid_le32) return 0;
         break;
     case 'c':
-        if (pid && !checkscript()) return 0;
+        if (pid_le32 && !checkscript()) return 0;
         break;
     case 't':
-        if (!pid && svstatus.want == 'd') break;
+        if (!pid_le32 && svstatus.want == 'd') break;
         timestamp = SWAP_BE64(svstatus.time_be64);
-        if ((tstart > timestamp) || !pid || svstatus.got_term || !checkscript())
+        if ((tstart > timestamp) || !pid_le32 || svstatus.got_term || !checkscript())
             return 0;
         break;
     case 'o':
         timestamp = SWAP_BE64(svstatus.time_be64);
-        if ((!pid && tstart > timestamp) || (pid && svstatus.want != 'd'))
+        if ((!pid_le32 && tstart > timestamp) || (pid_le32 && svstatus.want != 'd'))
             return 0;
     }
     printf(OK);
     svstatus_print(*service);
-    puts(""); /* will also flush the output */
+    bb_putchar('\n'); /* will also flush the output */
     return 1;
 }
@@ -379 +391 @@
 static int control(const char *a)
 {
-    int fd, r;
-
+    int fd, r, l;
+
+/* Is it an optimization?
+   It causes problems with "sv o SRV; ...; sv d SRV"
+   ('d' is not passed to SRV because its .want == 'd'):
     if (svstatus_get() <= 0)
         return -1;
     if (svstatus.want == *a)
         return 0;
-    fd = open_write("supervise/control");
+*/
+    fd = open("supervise/control", O_WRONLY|O_NDELAY);
     if (fd == -1) {
         if (errno != ENODEV)
-            warn("cannot open supervise/control");
+            warn("can't open supervise/control");
         else
             *a == 'x' ? ok("runsv not running") : failx("runsv not running");
         return -1;
     }
-    r = write(fd, a, strlen(a));
+    l = strlen(a);
+    r = write(fd, a, l);
     close(fd);
-    if (r != strlen(a)) {
-        warn("cannot write to supervise/control");
+    if (r != l) {
+        warn("can't write to supervise/control");
         return -1;
     }
@@ -402 +419 @@
 }
 
-int sv_main(int argc, char **argv);
-int sv_main(int argc, char **argv)
+int sv_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int sv_main(int argc UNUSED_PARAM, char **argv)
 {
     unsigned opt;
-    unsigned i, want_exit;
     char *x;
     char *action;
-    const char *varservice = "/var/service/";
-    unsigned services;
-    char **servicex;
+    const char *varservice = CONFIG_SV_DEFAULT_SERVICE_DIR;
     unsigned waitsec = 7;
     smallint kll = 0;
-    smallint verbose = 0;
+    int verbose = 0;
     int (*act)(const char*);
     int (*cbk)(const char*);
     int curdir;
+
+    INIT_G();
 
     xfunc_error_retval = 100;
@@ -426 +442 @@
     if (x) waitsec = xatou(x);
 
-    opt = getopt32(argv, "w:v", &x);
-    if (opt & 1) waitsec = xatou(x); // -w
-    if (opt & 2) verbose = 1; // -v
-    argc -= optind;
+    opt_complementary = "w+:vv"; /* -w N, -v is a counter */
+    opt = getopt32(argv, "w:v", &waitsec, &verbose);
     argv += optind;
     action = *argv++;
     if (!action || !*argv) bb_show_usage();
-    service = argv;
-    services = argc - 1;
-
-    tnow = time(0) + 0x400000000000000aULL;
+
+    tnow = time(NULL) + 0x400000000000000aULL;
     tstart = tnow;
-    curdir = open_read(".");
+    curdir = open(".", O_RDONLY|O_NDELAY);
     if (curdir == -1)
         fatal_cannot("open current directory");
@@ -525 +537 @@
     }
 
-    servicex = service;
-    for (i = 0; i < services; ++i) {
-        if ((**service != '/') && (**service != '.')) {
+    service = argv;
+    while ((x = *service) != NULL) {
+        if (x[0] != '/' && x[0] != '.') {
             if (chdir(varservice) == -1)
                 goto chdir_failed_0;
         }
-        if (chdir(*service) == -1) {
+        if (chdir(x) == -1) {
  chdir_failed_0:
-            fail("cannot change to service directory");
+            fail("can't change to service directory");
             goto nullify_service_0;
         }
         if (act && (act(acts) == -1)) {
  nullify_service_0:
-            *service = NULL;
+            *service = (char*) -1L; /* "dead" */
         }
         if (fchdir(curdir) == -1)
@@ -546 +558 @@
 
     if (cbk) while (1) {
+        int want_exit;
         int diff;
 
         diff = tnow - tstart;
-        service = servicex;
+        service = argv;
         want_exit = 1;
-        for (i = 0; i < services; ++i, ++service) {
-            if (!*service)
-                continue;
-            if ((**service != '/') && (**service != '.')) {
+        while ((x = *service) != NULL) {
+            if (x == (char*) -1L) /* "dead" */
+                goto next;
+            if (x[0] != '/' && x[0] != '.') {
                 if (chdir(varservice) == -1)
                     goto chdir_failed;
             }
-            if (chdir(*service) == -1) {
+            if (chdir(x) == -1) {
  chdir_failed:
-                fail("cannot change to service directory");
+                fail("can't change to service directory");
                 goto nullify_service;
             }
@@ -569 +582 @@
                 printf(kll ? "kill: " : "timeout: ");
                 if (svstatus_get() > 0) {
-                    svstatus_print(*service);
+                    svstatus_print(x);
                     ++rc;
                 }
-                puts(""); /* will also flush the output */
+                bb_putchar('\n'); /* will also flush the output */
                 if (kll)
                     control("k");
  nullify_service:
-                *service = NULL;
+                *service = (char*) -1L; /* "dead" */
             }
             if (fchdir(curdir) == -1)
                 fatal_cannot("change to original directory");
+ next:
+            service++;
         }
         if (want_exit) break;
         usleep(420000);
-        tnow = time(0) + 0x400000000000000aULL;
+        tnow = time(NULL) + 0x400000000000000aULL;
     }
     return rc > 99 ? 99 : rc;

branches/2.2.9/mindi-busybox/runit/svlogd.c

@@ -26 +26 @@
 */
 
-/* Busyboxed by Denis Vlasenko <vda.linux@googlemail.com> */
+/* Busyboxed by Denys Vlasenko <vda.linux@googlemail.com> */
 /* TODO: depends on runit_lib.c - review and reduce/eliminate */
+
+/*
+Config files
+
+On startup, and after receiving a HUP signal, svlogd checks for each
+log directory log if the configuration file log/config exists,
+and if so, reads the file line by line and adjusts configuration
+for log as follows:
+
+If the line is empty, or starts with a #, it is ignored. A line
+of the form
+
+ssize
+    sets the maximum file size of current when svlogd should rotate
+    the current log file to size bytes. Default is 1000000.
+    If size is zero, svlogd doesnt rotate log files
+    You should set size to at least (2 * len).
+nnum
+    sets the number of old log files svlogd should maintain to num.
+    If svlogd sees more that num old log files in log after log file
+    rotation, it deletes the oldest one. Default is 10.
+    If num is zero, svlogd doesnt remove old log files.
+Nmin
+    sets the minimum number of old log files svlogd should maintain
+    to min. min must be less than num. If min is set, and svlogd
+    cannot write to current because the filesystem is full,
+    and it sees more than min old log files, it deletes the oldest one.
+ttimeout
+    sets the maximum age of the current log file when svlogd should
+    rotate the current log file to timeout seconds. If current
+    is timeout seconds old, and is not empty, svlogd forces log file rotation.
+!processor
+    tells svlogd to feed each recent log file through processor
+    (see above) on log file rotation. By default log files are not processed.
+ua.b.c.d[:port]
+    tells svlogd to transmit the first len characters of selected
+    log messages to the IP address a.b.c.d, port number port.
+    If port isnt set, the default port for syslog is used (514).
+    len can be set through the -l option, see below. If svlogd
+    has trouble sending udp packets, it writes error messages
+    to the log directory. Attention: logging through udp is unreliable,
+    and should be used in private networks only.
+Ua.b.c.d[:port]
+    is the same as the u line above, but the log messages are no longer
+    written to the log directory, but transmitted through udp only.
+    Error messages from svlogd concerning sending udp packages still go
+    to the log directory.
+pprefix
+    tells svlogd to prefix each line to be written to the log directory,
+    to standard error, or through UDP, with prefix.
+
+If a line starts with a -, +, e, or E, svlogd matches the first len characters
+of each log message against pattern and acts accordingly:
+
+-pattern
+    the log message is deselected.
++pattern
+    the log message is selected.
+epattern
+    the log message is selected to be printed to standard error.
+Epattern
+    the log message is deselected to be printed to standard error.
+
+Initially each line is selected to be written to log/current. Deselected
+log messages are discarded from log. Initially each line is deselected
+to be written to standard err. Log messages selected for standard error
+are written to standard error.
+
+Pattern Matching
+
+svlogd matches a log message against the string pattern as follows:
+
+pattern is applied to the log message one character by one, starting
+with the first. A character not a star (*) and not a plus (+) matches itself.
+A plus matches the next character in pattern in the log message one
+or more times. A star before the end of pattern matches any string
+in the log message that does not include the next character in pattern.
+A star at the end of pattern matches any string.
+
+Timestamps optionally added by svlogd are not considered part
+of the log message.
+
+An svlogd pattern is not a regular expression. For example consider
+a log message like this
+
+2005-12-18_09:13:50.97618 tcpsvd: info: pid 1977 from 10.4.1.14
+
+The following pattern doesnt match
+
+-*pid*
+
+because the first star matches up to the first p in tcpsvd,
+and then the match fails because i is not s. To match this
+log message, you can use a pattern like this instead
+
+-*: *: pid *
+*/
 
 #include <sys/poll.h>
@@ -38 +135 @@
 #define FMT_PTIME 30
 
-static unsigned verbose;
-static int linemax = 1000;
-////static int buflen = 1024;
-static int linelen;
-
-static char **fndir;
-static int fdwdir;
-static int wstat;
-static unsigned nearest_rotate;
-
-static char *line;
-static smallint exitasap;
-static smallint rotateasap;
-static smallint reopenasap;
-static smallint linecomplete = 1;
-
-static smallint tmaxflag;
-
-static char repl;
-static const char *replace = "";
-
-static sigset_t *blocked_sigset;
-static int fl_flag_0;
-
-static struct logdir {
+struct logdir {
     ////char *btmp;
     /* pattern list to match, in "aa\0bb\0\cc\0\0" form */
@@ -82 +155 @@
     char match;
     char matcherr;
-} *dir;
-static unsigned dirn;
+};
+
+
+struct globals {
+    struct logdir *dir;
+    unsigned verbose;
+    int linemax;
+    ////int buflen;
+    int linelen;
+
+    int fdwdir;
+    char **fndir;
+    int wstat;
+    unsigned nearest_rotate;
+
+    void* (*memRchr)(const void *, int, size_t);
+
+    smallint exitasap;
+    smallint rotateasap;
+    smallint reopenasap;
+    smallint linecomplete;
+    smallint tmaxflag;
+
+    char repl;
+    const char *replace;
+    int fl_flag_0;
+    unsigned dirn;
+
+    sigset_t blocked_sigset;
+};
+#define G (*ptr_to_globals)
+#define dir            (G.dir           )
+#define verbose        (G.verbose       )
+#define linemax        (G.linemax       )
+#define buflen         (G.buflen        )
+#define linelen        (G.linelen       )
+#define fndir          (G.fndir         )
+#define fdwdir         (G.fdwdir        )
+#define wstat          (G.wstat         )
+#define memRchr        (G.memRchr       )
+#define nearest_rotate (G.nearest_rotate)
+#define exitasap       (G.exitasap      )
+#define rotateasap     (G.rotateasap    )
+#define reopenasap     (G.reopenasap    )
+#define linecomplete   (G.linecomplete  )
+#define tmaxflag       (G.tmaxflag      )
+#define repl           (G.repl          )
+#define replace        (G.replace       )
+#define blocked_sigset (G.blocked_sigset)
+#define fl_flag_0      (G.fl_flag_0     )
+#define dirn           (G.dirn          )
+#define INIT_G() do { \
+    SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
+    linemax = 1000; \
+    /*buflen = 1024;*/ \
+    linecomplete = 1; \
+    replace = ""; \
+} while (0)
+
+#define line bb_common_bufsiz1
+
 
 #define FATAL "fatal: "
@@ -90 +222 @@
 #define INFO "info: "
 
-#define usage() bb_show_usage()
 static void fatalx(const char *m0)
 {
@@ -114 +245 @@
 static void pause1cannot(const char *m0)
 {
-    bb_perror_msg(PAUSE"cannot %s", m0);
+    bb_perror_msg(PAUSE"can't %s", m0);
     sleep(3);
 }
 static void pause2cannot(const char *m0, const char *m1)
 {
-    bb_perror_msg(PAUSE"cannot %s %s", m0, m1);
+    bb_perror_msg(PAUSE"can't %s %s", m0, m1);
     sleep(3);
 }
@@ -131 +262 @@
 }
 
+static unsigned pmatch(const char *p, const char *s, unsigned len)
+{
+    for (;;) {
+        char c = *p++;
+        if (!c) return !len;
+        switch (c) {
+        case '*':
+            c = *p;
+            if (!c) return 1;
+            for (;;) {
+                if (!len) return 0;
+                if (*s == c) break;
+                ++s;
+                --len;
+            }
+            continue;
+        case '+':
+            c = *p++;
+            if (c != *s) return 0;
+            for (;;) {
+                if (!len) return 1;
+                if (*s != c) break;
+                ++s;
+                --len;
+            }
+            continue;
+            /*
+        case '?':
+            if (*p == '?') {
+                if (*s != '?') return 0;
+                ++p;
+            }
+            ++s; --len;
+            continue;
+            */
+        default:
+            if (!len) return 0;
+            if (*s != c) return 0;
+            ++s;
+            --len;
+            continue;
+        }
+    }
+    return 0;
+}
+
 /*** ex fmt_ptime.[ch] ***/
 
@@ -136 +313 @@
 static void fmt_time_human_30nul(char *s)
 {
-    struct tm *t;
+    struct tm *ptm;
     struct timeval tv;
 
     gettimeofday(&tv, NULL);
-    t = gmtime(&(tv.tv_sec));
+    ptm = gmtime(&tv.tv_sec);
     sprintf(s, "%04u-%02u-%02u_%02u:%02u:%02u.%06u000",
-        (unsigned)(1900 + t->tm_year),
-        (unsigned)(t->tm_mon + 1),
-        (unsigned)(t->tm_mday),
-        (unsigned)(t->tm_hour),
-        (unsigned)(t->tm_min),
-        (unsigned)(t->tm_sec),
+        (unsigned)(1900 + ptm->tm_year),
+        (unsigned)(ptm->tm_mon + 1),
+        (unsigned)(ptm->tm_mday),
+        (unsigned)(ptm->tm_hour),
+        (unsigned)(ptm->tm_min),
+        (unsigned)(ptm->tm_sec),
         (unsigned)(tv.tv_usec)
     );
@@ -175 +352 @@
 }
 
-static unsigned processorstart(struct logdir *ld)
-{
+static void processorstart(struct logdir *ld)
+{
+    char sv_ch;
     int pid;
 
-    if (!ld->processor) return 0;
+    if (!ld->processor) return;
     if (ld->ppid) {
         warnx("processor already running", ld->name);
-        return 0;
-    }
-    while ((pid = fork()) == -1)
-        pause2cannot("fork for processor", ld->name);
+        return;
+    }
+
+    /* vfork'ed child trashes this byte, save... */
+    sv_ch = ld->fnsave[26];
+
+    while ((pid = vfork()) == -1)
+        pause2cannot("vfork for processor", ld->name);
     if (!pid) {
-        char *prog[4];
         int fd;
 
         /* child */
-        signal(SIGTERM, SIG_DFL);
-        signal(SIGALRM, SIG_DFL);
-        signal(SIGHUP, SIG_DFL);
+        /* Non-ignored signals revert to SIG_DFL on exec anyway */
+        /*bb_signals(0
+            + (1 << SIGTERM)
+            + (1 << SIGALRM)
+            + (1 << SIGHUP)
+            , SIG_DFL);*/
         sig_unblock(SIGTERM);
         sig_unblock(SIGALRM);
@@ -202 +386 @@
         fd = xopen(ld->fnsave, O_RDONLY|O_NDELAY);
         xmove_fd(fd, 0);
-        ld->fnsave[26] = 't';
+        ld->fnsave[26] = 't'; /* <- that's why we need sv_ch! */
         fd = xopen(ld->fnsave, O_WRONLY|O_NDELAY|O_TRUNC|O_CREAT);
         xmove_fd(fd, 1);
-        fd = open_read("state");
+        fd = open("state", O_RDONLY|O_NDELAY);
         if (fd == -1) {
             if (errno != ENOENT)
-                bb_perror_msg_and_die(FATAL"cannot %s processor %s", "open state for", ld->name);
+                bb_perror_msg_and_die(FATAL"can't %s processor %s", "open state for", ld->name);
             close(xopen("state", O_WRONLY|O_NDELAY|O_TRUNC|O_CREAT));
             fd = xopen("state", O_RDONLY|O_NDELAY);
@@ -217 +401 @@
 
 // getenv("SHELL")?
-        prog[0] = (char*)"sh";
-        prog[1] = (char*)"-c";
-        prog[2] = ld->processor;
-        prog[3] = NULL;
-        execve("/bin/sh", prog, environ);
-        bb_perror_msg_and_die(FATAL"cannot %s processor %s", "run", ld->name);
-    }
+        execl(DEFAULT_SHELL, DEFAULT_SHELL_SHORT_NAME, "-c", ld->processor, (char*) NULL);
+        bb_perror_msg_and_die(FATAL"can't %s processor %s", "run", ld->name);
+    }
+    ld->fnsave[26] = sv_ch; /* ...restore */
     ld->ppid = pid;
-    return 1;
 }
 
@@ -234 +414 @@
     if (ld->ppid) {
         sig_unblock(SIGHUP);
-        while (wait_pid(&wstat, ld->ppid) == -1)
+        while (safe_waitpid(ld->ppid, &wstat, 0) == -1)
             pause2cannot("wait for processor", ld->name);
         sig_block(SIGHUP);
         ld->ppid = 0;
     }
-    if (ld->fddir == -1) return 1;
+    if (ld->fddir == -1)
+        return 1;
     while (fchdir(ld->fddir) == -1)
         pause2cannot("change directory, want processor", ld->name);
-    if (wait_exitcode(wstat) != 0) {
+    if (WEXITSTATUS(wstat) != 0) {
         warnx("processor failed, restart", ld->name);
         ld->fnsave[26] = 't';
@@ -262 +443 @@
     ld->fnsave[26] = 'u';
     if (unlink(ld->fnsave) == -1)
-        bb_error_msg(WARNING"cannot unlink: %s/%s", ld->name, ld->fnsave);
+        bb_error_msg(WARNING"can't unlink: %s/%s", ld->name, ld->fnsave);
     while (rename("newstate", "state") == -1)
         pause2cannot("rename state", ld->name);
@@ -287 +468 @@
             if (f->d_name[26] == 't') {
                 if (unlink(f->d_name) == -1)
-                    warn2("cannot unlink processor leftover", f->d_name);
+                    warn2("can't unlink processor leftover", f->d_name);
             } else {
                 ++n;
@@ -297 +478 @@
     }
     if (errno)
-        warn2("cannot read directory", ld->name);
+        warn2("can't read directory", ld->name);
     closedir(d);
 
@@ -304 +485 @@
             bb_error_msg(INFO"delete: %s/%s", ld->name, oldest);
         if ((*oldest == '@') && (unlink(oldest) == -1))
-            warn2("cannot unlink oldest logfile", ld->name);
+            warn2("can't unlink oldest logfile", ld->name);
     }
 }
@@ -359 +540 @@
         while ((ld->fdcur = open("current", O_WRONLY|O_NDELAY|O_APPEND|O_CREAT, 0600)) == -1)
             pause2cannot("create new current", ld->name);
-        /* we presume this cannot fail */
-        ld->filecur = fdopen(ld->fdcur, "a"); ////
+        while ((ld->filecur = fdopen(ld->fdcur, "a")) == NULL) ////
+            pause2cannot("create new current", ld->name); /* very unlikely */
         setvbuf(ld->filecur, NULL, _IOFBF, linelen); ////
-        coe(ld->fdcur);
+        close_on_exec_on(ld->fdcur);
         ld->size = 0;
         while (fchmod(ld->fdcur, 0644) == -1)
             pause2cannot("set mode of current", ld->name);
+
         rmoldest(ld);
         processorstart(ld);
@@ -413 +595 @@
                         memcpy(oldest, f->d_name, 27);
                 }
-            if (errno) warn2("cannot read directory, want remove old logfile",
+            if (errno) warn2("can't read directory, want remove old logfile",
                     ld->name);
             closedir(d);
@@ -423 +605 @@
                     errno = 0;
                     if (unlink(oldest) == -1) {
-                        warn2("cannot unlink oldest logfile", ld->name);
+                        warn2("can't unlink oldest logfile", ld->name);
                         errno = ENOSPC;
                     }
@@ -468 +650 @@
 }
 
-static unsigned logdir_open(struct logdir *ld, const char *fn)
+static NOINLINE unsigned logdir_open(struct logdir *ld, const char *fn)
 {
     char buf[128];
@@ -480 +662 @@
     ld->fddir = open(fn, O_RDONLY|O_NDELAY);
     if (ld->fddir == -1) {
-        warn2("cannot open log directory", (char*)fn);
+        warn2("can't open log directory", (char*)fn);
         return 0;
     }
-    coe(ld->fddir);
+    close_on_exec_on(ld->fddir);
     if (fchdir(ld->fddir) == -1) {
         logdir_close(ld);
-        warn2("cannot change directory", (char*)fn);
+        warn2("can't change directory", (char*)fn);
         return 0;
     }
     ld->fdlock = open("lock", O_WRONLY|O_NDELAY|O_APPEND|O_CREAT, 0600);
     if ((ld->fdlock == -1)
-     || (lock_exnb(ld->fdlock) == -1)
+     || (flock(ld->fdlock, LOCK_EX | LOCK_NB) == -1)
     ) {
         logdir_close(ld);
-        warn2("cannot lock directory", (char*)fn);
+        warn2("can't lock directory", (char*)fn);
         while (fchdir(fdwdir) == -1)
             pause1cannot("change to initial working directory");
         return 0;
     }
-    coe(ld->fdlock);
+    close_on_exec_on(ld->fdlock);
 
     ld->size = 0;
@@ -512 +694 @@
 
     /* read config */
-    i = open_read_close("config", buf, sizeof(buf));
+    i = open_read_close("config", buf, sizeof(buf) - 1);
     if (i < 0 && errno != ENOENT)
         bb_perror_msg(WARNING"%s/config", ld->name);
     if (i > 0) {
+        buf[i] = '\0';
         if (verbose)
             bb_error_msg(INFO"read: %s/config", ld->name);
@@ -528 +711 @@
             case 'e':
             case 'E':
+                /* Filtering requires one-line buffering,
+                 * resetting the "find newline" function
+                 * accordingly */
+                memRchr = memchr;
                 /* Add '\n'-terminated line to ld->inst */
                 while (1) {
-                    int l = asprintf(&new, "%s%s\n", ld->inst ? : "", s);
+                    int l = asprintf(&new, "%s%s\n", ld->inst ? ld->inst : "", s);
                     if (l >= 0 && new)
                         break;
@@ -542 +729 @@
                     { "k", 1024 },
                     { "m", 1024*1024 },
-                    { }
+                    { "", 0 }
                 };
                 ld->sizemax = xatou_sfx(&s[1], km_suffixes);
@@ -548 +735 @@
             }
             case 'n':
-                ld->nmax = xatoi_u(&s[1]);
+                ld->nmax = xatoi_positive(&s[1]);
                 break;
             case 'N':
-                ld->nmin = xatoi_u(&s[1]);
+                ld->nmin = xatoi_positive(&s[1]);
                 break;
             case 't': {
@@ -558 +745 @@
                     { "h", 60*60 },
                     /*{ "d", 24*60*60 },*/
-                    { }
+                    { "", 0 }
                 };
                 ld->rotate_period = xatou_sfx(&s[1], mh_suffixes);
@@ -613 +800 @@
         if (errno != ENOENT) {
             logdir_close(ld);
-            warn2("cannot stat current", ld->name);
+            warn2("can't stat current", ld->name);
             while (fchdir(fdwdir) == -1)
                 pause1cannot("change to initial working directory");
@@ -621 +808 @@
     while ((ld->fdcur = open("current", O_WRONLY|O_NDELAY|O_APPEND|O_CREAT, 0600)) == -1)
         pause2cannot("open current", ld->name);
-    /* we presume this cannot fail */
-    ld->filecur = fdopen(ld->fdcur, "a"); ////
+    while ((ld->filecur = fdopen(ld->fdcur, "a")) == NULL)
+        pause2cannot("open current", ld->name); ////
     setvbuf(ld->filecur, NULL, _IOFBF, linelen); ////
 
-    coe(ld->fdcur);
+    close_on_exec_on(ld->fdcur);
     while (fchmod(ld->fdcur, 0644) == -1)
         pause2cannot("set mode of current", ld->name);
@@ -666 +853 @@
 
 /* Used for reading stdin */
-static int buffer_pread(int fd, char *s, unsigned len)
+static int buffer_pread(/*int fd, */char *s, unsigned len)
 {
     unsigned now;
@@ -672 +859 @@
     int i;
 
-    input.fd = 0;
+    input.fd = STDIN_FILENO;
     input.events = POLLIN;
 
@@ -701 +888 @@
         }
 
-        sigprocmask(SIG_UNBLOCK, blocked_sigset, NULL);
+        sigprocmask(SIG_UNBLOCK, &blocked_sigset, NULL);
         i = nearest_rotate - now;
         if (i > 1000000)
@@ -708 +895 @@
             i = 1;
         poll(&input, 1, i * 1000);
-        sigprocmask(SIG_BLOCK, blocked_sigset, NULL);
-
-        i = ndelay_read(fd, s, len);
+        sigprocmask(SIG_BLOCK, &blocked_sigset, NULL);
+
+        i = ndelay_read(STDIN_FILENO, s, len);
         if (i >= 0)
             break;
@@ -716 +903 @@
             continue;
         if (errno != EAGAIN) {
-            warn("cannot read standard input");
+            warn("can't read standard input");
             break;
         }
@@ -750 +937 @@
 }
 
-static void sig_term_handler(int sig_no)
+static void sig_term_handler(int sig_no UNUSED_PARAM)
 {
     if (verbose)
@@ -757 +944 @@
 }
 
-static void sig_child_handler(int sig_no)
-{
-    int pid, l;
+static void sig_child_handler(int sig_no UNUSED_PARAM)
+{
+    pid_t pid;
+    int l;
 
     if (verbose)
         bb_error_msg(INFO"sig%s received", "child");
-    while ((pid = wait_nohang(&wstat)) > 0) {
+    while ((pid = wait_any_nohang(&wstat)) > 0) {
         for (l = 0; l < dirn; ++l) {
             if (dir[l].ppid == pid) {
@@ -774 +962 @@
 }
 
-static void sig_alarm_handler(int sig_no)
+static void sig_alarm_handler(int sig_no UNUSED_PARAM)
 {
     if (verbose)
@@ -781 +969 @@
 }
 
-static void sig_hangup_handler(int sig_no)
+static void sig_hangup_handler(int sig_no UNUSED_PARAM)
 {
     if (verbose)
@@ -812 +1000 @@
 }
 
-int svlogd_main(int argc, char **argv);
+int svlogd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int svlogd_main(int argc, char **argv)
 {
-    sigset_t ss;
-    char *r,*l,*b;
+    char *r, *l, *b;
     ssize_t stdin_cnt = 0;
     int i;
     unsigned opt;
     unsigned timestamp = 0;
-    void* (*memRchr)(const void *, int, size_t) = memchr;
-
-#define line bb_common_bufsiz1
+
+    INIT_G();
 
     opt_complementary = "tt:vv";
@@ -830 +1016 @@
     if (opt & 1) { // -r
         repl = r[0];
-        if (!repl || r[1]) usage();
+        if (!repl || r[1])
+            bb_show_usage();
     }
     if (opt & 2) if (!repl) repl = '_'; // -R
     if (opt & 4) { // -l
         linemax = xatou_range(l, 0, BUFSIZ-26);
-        if (linemax == 0) linemax = BUFSIZ-26;
-        if (linemax < 256) linemax = 256;
+        if (linemax == 0)
+            linemax = BUFSIZ-26;
+        if (linemax < 256)
+            linemax = 256;
     }
     ////if (opt & 8) { // -b
-    ////    buflen = xatoi_u(b);
+    ////    buflen = xatoi_positive(b);
     ////    if (buflen == 0) buflen = 1024;
     ////}
@@ -849 +1038 @@
 
     dirn = argc;
-    if (dirn <= 0) usage();
-    ////if (buflen <= linemax) usage();
+    if (dirn <= 0)
+        bb_show_usage();
+    ////if (buflen <= linemax) bb_show_usage();
     fdwdir = xopen(".", O_RDONLY|O_NDELAY);
-    coe(fdwdir);
-    dir = xzalloc(dirn * sizeof(struct logdir));
+    close_on_exec_on(fdwdir);
+    dir = xzalloc(dirn * sizeof(dir[0]));
     for (i = 0; i < dirn; ++i) {
         dir[i].fddir = -1;
@@ -867 +1057 @@
     fl_flag_0 = fcntl(0, F_GETFL);
 
-    blocked_sigset = &ss;
-    sigemptyset(&ss);
-    sigaddset(&ss, SIGTERM);
-    sigaddset(&ss, SIGCHLD);
-    sigaddset(&ss, SIGALRM);
-    sigaddset(&ss, SIGHUP);
-    sigprocmask(SIG_BLOCK, &ss, NULL);
-    sig_catch(SIGTERM, sig_term_handler);
-    sig_catch(SIGCHLD, sig_child_handler);
-    sig_catch(SIGALRM, sig_alarm_handler);
-    sig_catch(SIGHUP, sig_hangup_handler);
-
-    logdirs_reopen();
+    sigemptyset(&blocked_sigset);
+    sigaddset(&blocked_sigset, SIGTERM);
+    sigaddset(&blocked_sigset, SIGCHLD);
+    sigaddset(&blocked_sigset, SIGALRM);
+    sigaddset(&blocked_sigset, SIGHUP);
+    sigprocmask(SIG_BLOCK, &blocked_sigset, NULL);
+    bb_signals_recursive_norestart(1 << SIGTERM, sig_term_handler);
+    bb_signals_recursive_norestart(1 << SIGCHLD, sig_child_handler);
+    bb_signals_recursive_norestart(1 << SIGALRM, sig_alarm_handler);
+    bb_signals_recursive_norestart(1 << SIGHUP, sig_hangup_handler);
 
     /* Without timestamps, we don't have to print each line
      * separately, so we can look for _last_ newline, not first,
-     * thus batching writes */
-    if (!timestamp)
-        memRchr = memrchr;
+     * thus batching writes. If filtering is enabled in config,
+     * logdirs_reopen resets it to memchr.
+     */
+    memRchr = (timestamp ? memchr : memrchr);
+
+    logdirs_reopen();
 
     setvbuf(stderr, NULL, _IOFBF, linelen);
@@ -910 +1100 @@
             i = linemax - stdin_cnt; /* avail. bytes at tail */
             if (i >= 128) {
-                i = buffer_pread(0, lineptr + stdin_cnt, i);
+                i = buffer_pread(/*0, */lineptr + stdin_cnt, i);
                 if (i <= 0) /* EOF or error on stdin */
                     exitasap = 1;
@@ -925 +1115 @@
         linelen = stdin_cnt;
         if (np) {
- print_to_nl:       /* NB: starting from here lineptr may point
+ print_to_nl:
+            /* NB: starting from here lineptr may point
              * farther out into line[] */
             linelen = np - lineptr + 1;
@@ -953 +1144 @@
         for (i = 0; i < dirn; ++i) {
             struct logdir *ld = &dir[i];
-            if (ld->fddir == -1) continue;
+            if (ld->fddir == -1)
+                continue;
             if (ld->inst)
                 logmatch(ld);
-            if (ld->matcherr == 'e')
-                ////full_write(2, printptr, printlen);
-                fwrite(lineptr, 1, linelen, stderr);
-            if (ld->match != '+') continue;
+            if (ld->matcherr == 'e') {
+                /* runit-1.8.0 compat: if timestamping, do it on stderr too */
+                ////full_write(STDERR_FILENO, printptr, printlen);
+                fwrite(printptr, 1, printlen, stderr);
+            }
+            if (ld->match != '+')
+                continue;
             buffer_pwrite(i, printptr, printlen);
         }
@@ -967 +1162 @@
         while (ch != '\n') {
             /* lineptr is emptied now, safe to use as buffer */
-            stdin_cnt = exitasap ? -1 : buffer_pread(0, lineptr, linemax);
+            stdin_cnt = exitasap ? -1 : buffer_pread(/*0, */lineptr, linemax);
             if (stdin_cnt <= 0) { /* EOF or error on stdin */
                 exitasap = 1;
@@ -982 +1177 @@
             /* linelen == no of chars incl. '\n' (or == stdin_cnt) */
             for (i = 0; i < dirn; ++i) {
-                if (dir[i].fddir == -1) continue;
-                if (dir[i].matcherr == 'e')
-                    ////full_write(2, lineptr, linelen);
+                if (dir[i].fddir == -1)
+                    continue;
+                if (dir[i].matcherr == 'e') {
+                    ////full_write(STDERR_FILENO, lineptr, linelen);
                     fwrite(lineptr, 1, linelen, stderr);
-                if (dir[i].match != '+') continue;
+                }
+                if (dir[i].match != '+')
+                    continue;
                 buffer_pwrite(i, lineptr, linelen);
             }
@@ -1002 +1200 @@
             memmove((timestamp ? line+26 : line), lineptr, stdin_cnt);
         }
-        fflush(NULL);////
+        fflush_all();////
     }
 
@@ -1008 +1206 @@
         if (dir[i].ppid)
             while (!processorstop(&dir[i]))
-                /* repeat */;
+                continue;
         logdir_close(&dir[i]);
     }