Merge branch 'busybox' into merge

2 files changed, 47 insertions, 23 deletions

diff --git a/runit/runsv.c b/runit/runsv.c
index ecab8cdf5..a4b8af494 100644
--- a/runit/runsv.c
+++ b/runit/runsv.c
@@ -149,17 +149,18 @@ static void warn_cannot(const char *m)
         warn2_cannot(m, "");
 }
 
-static void s_child(int sig_no UNUSED_PARAM)
+/* SIGCHLD/TERM handler is reentrancy-safe because they are unmasked
+ * only over poll() call, not over memory allocations
+ * or printouts. Do not need to save/restore errno either,
+ * as poll() error is not checked there.
+ */
+static void s_chld_term(int sig_no)
 {
+        if (sig_no == SIGTERM)
+                sigterm = 1;
         write(selfpipe.wr, "", 1);
 }
 
-static void s_term(int sig_no UNUSED_PARAM)
-{
-        sigterm = 1;
-        write(selfpipe.wr, "", 1); /* XXX */
-}
-
 static int open_trunc_or_warn(const char *name)
 {
         /* Why O_NDELAY? */
@@ -380,11 +381,14 @@ static void startservice(struct svdir *s)
                                 xdup2(logpipe.wr, 1);
                         }
                 }
-                /* Non-ignored signals revert to SIG_DFL on exec anyway */
-                /*bb_signals(0
-                        + (1 << SIGCHLD)
-                        + (1 << SIGTERM)
-                        , SIG_DFL);*/
+                /* Non-ignored signals revert to SIG_DFL on exec.
+                 * But we can get signals BEFORE execl(), unlikely as that may be.
+                 * SIGCHLD is safe (would merely write to selfpipe),
+                 * but SIGTERM would set sigterm = 1 (with vfork, we affect parent).
+                 * Avoid that.
+                 */
+                /*signal(SIGCHLD, SIG_DFL);*/
+                signal(SIGTERM, SIG_DFL);
                 sig_unblock(SIGCHLD);
                 sig_unblock(SIGTERM);
                 execv(arg[0], (char**) arg);
@@ -511,9 +515,15 @@ int runsv_main(int argc UNUSED_PARAM, char **argv)
         ndelay_on(selfpipe.wr);
 
         sig_block(SIGCHLD);
-        bb_signals_recursive_norestart(1 << SIGCHLD, s_child);
         sig_block(SIGTERM);
-        bb_signals_recursive_norestart(1 << SIGTERM, s_term);
+        /* No particular reason why we don't set SA_RESTART
+         * (poll() wouldn't restart regardless of that flag),
+         * we just follow what runit-2.1.2 does:
+         */
+        bb_signals_norestart(0
+                        + (1 << SIGCHLD)
+                        + (1 << SIGTERM)
+                        , s_chld_term);
 
         xchdir(dir);
         /* bss: svd[0].pid = 0; */
@@ -625,6 +635,7 @@ int runsv_main(int argc UNUSED_PARAM, char **argv)
                 sig_unblock(SIGTERM);
                 sig_unblock(SIGCHLD);
                 poll(x, 2 + haslog, 3600*1000);
+                /* NB: signal handlers can trash errno of poll() */
                 sig_block(SIGTERM);
                 sig_block(SIGCHLD);
 
diff --git a/runit/svlogd.c b/runit/svlogd.c
index 294e31aca..02c305696 100644
--- a/runit/svlogd.c
+++ b/runit/svlogd.c
@@ -412,19 +412,32 @@ static void processorstart(struct logdir *ld)
                 int fd;
 
                 /* child */
-                /* Non-ignored signals revert to SIG_DFL on exec anyway */
+                /* Non-ignored signals revert to SIG_DFL on exec anyway.
+                 * But we can get signals BEFORE execl(), this is unlikely
+                 * but wouldn't be good...
+                 */
                 /*bb_signals(0
                         + (1 << SIGTERM)
+                        //+ (1 << SIGCHLD)
                         + (1 << SIGALRM)
                         + (1 << SIGHUP)
                         , SIG_DFL);*/
-                sig_unblock(SIGTERM);
-                sig_unblock(SIGALRM);
-                sig_unblock(SIGHUP);
+                /* runit 2.1.2 does not unblock SIGCHLD, a bug? we do: */
+                sigprocmask(SIG_UNBLOCK, &blocked_sigset, NULL);
 
                 if (verbose)
                         bb_error_msg(INFO"processing: %s/%s", ld->name, ld->fnsave);
-                fd = xopen(ld->fnsave, O_RDONLY|O_NDELAY);
+
+                fd = open_or_warn(ld->fnsave, O_RDONLY|O_NDELAY);
+                /* Used to have xopen() above, but it causes infinite restarts of processor
+                 * if file is gone - which can happen even because of _us_!
+                 * Users report that if on reboot, time is reset to before existing
+                 * logfiles creation time, rmoldest() deletes the newest logfile (!)
+                 * and we end up here trying to open this now-deleted file.
+                 */
+                if (fd < 0)
+                        _exit(0); /* fake "success": do not run processor again */
+
                 xmove_fd(fd, 0);
                 ld->fnsave[26] = 't'; /* <- that's why we need sv_ch! */
                 fd = xopen(ld->fnsave, O_WRONLY|O_NDELAY|O_TRUNC|O_CREAT);
@@ -1098,10 +1111,10 @@ int svlogd_main(int argc, char **argv)
         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);
+        bb_signals_norestart(1 << SIGTERM, sig_term_handler);
+        bb_signals_norestart(1 << SIGCHLD, sig_child_handler);
+        bb_signals_norestart(1 << SIGALRM, sig_alarm_handler);
+        bb_signals_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,