ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-/* 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 */
#include <sys/poll.h>
/* Compare possibly overflowing unsigned counters */
#define LESS(a,b) ((int)((unsigned)(b) - (unsigned)(a)) > 0)
-static int selfpipe[2];
-
/* state */
#define S_DOWN 0
#define S_RUN 1
int pid;
smallint state;
smallint ctrl;
- smallint want;
+ smallint sd_want;
smallint islog;
struct timespec start;
int fdlock;
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)
{
bb_perror_msg("%s: warning: cannot %s", dir, m);
}
-static void s_child(int sig_no)
+static void s_child(int sig_no UNUSED_PARAM)
{
- write(selfpipe[1], "", 1);
+ write(selfpipe.wr, "", 1);
}
-static void s_term(int sig_no)
+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)
-{
- while ((*p = *to_add) != '\0') {
- p++;
- to_add++;
- }
- return p;
+ write(selfpipe.wr, "", 1); /* XXX */
}
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;
-}
-
static void update_status(struct svdir *s)
{
ssize_t sz;
char *p = stat_buf;
switch (s->state) {
case S_DOWN:
- p = add_str(p, "down");
+ p = stpcpy(p, "down");
break;
case S_RUN:
- p = add_str(p, "run");
+ p = stpcpy(p, "run");
break;
case S_FINISH:
- p = add_str(p, "finish");
+ p = 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 = stpcpy(p, ", paused");
+ if (s->ctrl & C_TERM)
+ p = 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 = stpcpy(p, ", want down");
break;
case W_EXIT:
- p = add_str(p, ", want exit");
+ p = stpcpy(p, ", want exit");
break;
}
*p++ = '\n';
status.pid_le32 = SWAP_LE32(s->pid);
if (s->ctrl & C_PAUSE)
status.paused = 1;
- if (s->want == W_UP)
+ if (s->sd_want == W_UP)
status.want = 'u';
else
status.want = 'd';
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 {
if (errno != ENOENT)
s->ctrl |= C_TERM;
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');
}
static void startservice(struct svdir *s)
{
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);
}
if (p == 0) {
/* 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]);
+ close(logpipe.rd);
+ xdup2(logpipe.wr, 1);
}
}
- signal(SIGCHLD, SIG_DFL);
- signal(SIGTERM, SIG_DFL);
+ /* 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);
s->state = S_RUN;
switch (c) {
case 'd': /* down */
- s->want = W_DOWN;
+ s->sd_want = W_DOWN;
update_status(s);
if (s->pid && s->state != S_FINISH)
stopservice(s);
break;
case 'u': /* up */
- s->want = W_UP;
+ s->sd_want = W_UP;
update_status(s);
if (s->pid == 0)
startservice(s);
case 'x': /* exit */
if (s->islog)
break;
- s->want = W_EXIT;
+ s->sd_want = W_EXIT;
update_status(s);
/* FALLTHROUGH */
case 't': /* sig term */
case 'c': /* sig cont */
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)
startservice(s);
return 1;
}
-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;
int fd;
int r;
char buf[256];
- if (!argv[1] || argv[2])
- bb_show_usage();
- dir = argv[1];
+ INIT_G();
+
+ dir = single_argv(argv);
- xpipe(selfpipe);
- coe(selfpipe[0]);
- coe(selfpipe[1]);
- ndelay_on(selfpipe[0]);
- ndelay_on(selfpipe[1]);
+ 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);
/* bss: svd[0].pid = 0; */
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) {
if (errno != ENOENT)
haslog = 1;
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);
}
}
}
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) {
r = readlink("log/supervise", buf, 256);
}
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 (;;) {
struct pollfd x[3];
char ch;
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;
x[1].events = POLLIN;
sig_block(SIGTERM);
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;
if ((child == -1) && (errno != EINTR))
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);
svd[0].state = S_FINISH;
}
if (haslog) {
if (child == svd[1].pid) {
+ svd[0].wstat = wstat;
svd[1].pid = 0;
pidchanged = 1;
svd[1].state = S_DOWN;
sleep(1);
}
}
- }
+ } /* for (;;) */
if (read(svd[0].fdcontrol, &ch, 1) == 1)
ctrl(&svd[0], ch);
if (haslog)
sigterm = 0;
}
- 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;
}
projects / oweals / busybox.git / blobdiff