detach stdin/stdout/stderr from child processes, implement a separate logging pipe...

diff --git a/main.c b/main.c
index 6419fe9..b07784e 100644 (file)
--- a/main.c
+++ b/main.c
@@ -3,6 +3,7 @@
 #include <string.h>
 #include <getopt.h>
 #include <unistd.h>
+#include <signal.h>
 
 #include "netifd.h"
 #include "ubus.h"
@@ -19,11 +20,83 @@ static struct list_head process_list = LIST_HEAD_INIT(process_list);
 static struct list_head fds = LIST_HEAD_INIT(fds);
 
 static void
+netifd_delete_process(struct netifd_process *proc)
+{
+       if (proc->uloop.pending)
+               uloop_process_delete(&proc->uloop);
+       list_del(&proc->list);
+       netifd_fd_delete(&proc->log_fd);
+}
+
+static void
+netifd_process_log_cb(struct uloop_fd *fd, unsigned int events)
+{
+       struct netifd_process *proc;
+       const char *log_prefix;
+       char *buf, *cur;
+       int maxlen, len, read_len;
+
+       proc = container_of(fd, struct netifd_process, log_uloop);
+
+       if (!proc->log_buf)
+               proc->log_buf = malloc(LOG_BUF_SIZE + 1);
+
+       buf = proc->log_buf + proc->log_buf_ofs;
+       maxlen = LOG_BUF_SIZE - proc->log_buf_ofs;
+
+       log_prefix = proc->log_prefix;
+       if (!log_prefix)
+               log_prefix = "process";
+
+retry:
+       read_len = len = read(fd->fd, buf, maxlen);
+       if (len <= 0) {
+               if (errno == EINTR)
+                       goto retry;
+
+               return;
+       }
+       proc->log_buf_ofs += len;
+
+       cur = buf;
+       buf = proc->log_buf;
+       while ((cur = memchr(cur, '\n', len))) {
+               *cur = 0;
+
+               if (!proc->log_overflow)
+                       fprintf(stderr, "%s (%d): %s\n", log_prefix, proc->uloop.pid, buf);
+               else
+                       proc->log_overflow = false;
+
+               cur++;
+               len -= cur - buf;
+               buf = cur;
+       }
+
+       if (buf > proc->log_buf && len > 0)
+               memmove(buf, proc->log_buf, len);
+
+       if (len == LOG_BUF_SIZE) {
+               if (!proc->log_overflow) {
+                       proc->log_buf[LOG_BUF_SIZE] = 0;
+                       fprintf(stderr, "%s (%d): %s [...]\n", log_prefix, proc->uloop.pid, proc->log_buf);
+                       proc->log_overflow = true;
+               }
+               len = 0;
+       }
+       proc->log_buf_ofs = len;
+
+       if (read_len == maxlen)
+               goto retry;
+}
+
+static void
 netifd_process_cb(struct uloop_process *proc, int ret)
 {
        struct netifd_process *np;
        np = container_of(proc, struct netifd_process, uloop);
-       list_del(&np->list);
+       netifd_process_log_cb(&np->log_uloop, 0);
+       netifd_delete_process(np);
        return np->cb(np, ret);
 }
 
@@ -31,13 +104,17 @@ int
 netifd_start_process(const char **argv, char **env, struct netifd_process *proc)
 {
        struct netifd_fd *fd;
+       int pfds[2];
        int pid;
 
        netifd_kill_process(proc);
 
-       if ((pid = fork()) < 0)
+       if (pipe(pfds) < 0)
                return -1;
 
+       if ((pid = fork()) < 0)
+               goto error;
+
        if (!pid) {
                if (env) {
                        while (*env) {
@@ -55,19 +132,37 @@ netifd_start_process(const char **argv, char **env, struct netifd_process *proc)
                        close(fd->fd);
                }
 
+               dup2(pfds[1], 0);
+               dup2(pfds[1], 1);
+               dup2(pfds[1], 2);
+
+               close(pfds[0]);
+               close(pfds[1]);
+
                execvp(argv[0], (char **) argv);
                exit(127);
        }
 
        if (pid < 0)
-               return -1;
+               goto error;
 
+       close(pfds[1]);
        proc->uloop.cb = netifd_process_cb;
        proc->uloop.pid = pid;
        uloop_process_add(&proc->uloop);
        list_add_tail(&proc->list, &process_list);
 
+       proc->log_uloop.fd = proc->log_fd.fd = pfds[0];
+       proc->log_uloop.cb = netifd_process_log_cb;
+       netifd_fd_add(&proc->log_fd);
+       uloop_fd_add(&proc->log_uloop, ULOOP_EDGE_TRIGGER | ULOOP_READ);
+
        return 0;
+
+error:
+       close(pfds[0]);
+       close(pfds[1]);
+       return -1;
 }
 
 void
@@ -77,8 +172,7 @@ netifd_kill_process(struct netifd_process *proc)
                return;
 
        kill(proc->uloop.pid, SIGTERM);
-       uloop_process_delete(&proc->uloop);
-       list_del(&proc->list);
+       netifd_delete_process(proc);
 }
 
 void
@@ -151,6 +245,9 @@ netifd_setup_signals(void)
        sigaction(SIGTERM, &s, NULL);
        sigaction(SIGUSR1, &s, NULL);
        sigaction(SIGUSR2, &s, NULL);
+
+       s.sa_handler = SIG_IGN;
+       sigaction(SIGPIPE, &s, NULL);
 }
 
 static void

diff --git a/netifd.h b/netifd.h
index 4129af7..316c746 100644 (file)
--- a/netifd.h
+++ b/netifd.h
@@ -44,6 +44,8 @@ enum {
 #define D(level, format, ...) no_debug(DEBUG_ ## level, format, ## __VA_ARGS__)
 #endif
 
+#define LOG_BUF_SIZE   256
+
 static inline void no_debug(int level, const char *fmt, ...)
 {
 }
@@ -59,6 +61,13 @@ struct netifd_process {
        struct uloop_process uloop;
        void (*cb)(struct netifd_process *, int ret);
        int dir_fd;
+
+       struct netifd_fd log_fd;
+       struct uloop_fd log_uloop;
+       const char *log_prefix;
+       char *log_buf;
+       int log_buf_ofs;
+       bool log_overflow;
 };
 
 int netifd_start_process(const char **argv, char **env, struct netifd_process *proc);

diff --git a/proto-shell.c b/proto-shell.c
index c0af99f..68af69b 100644 (file)
--- a/proto-shell.c
+++ b/proto-shell.c
@@ -470,10 +470,13 @@ proto_shell_attach(const struct proto_handler *h, struct interface *iface,
        state->setup_timeout.cb = proto_shell_setup_timeout_cb;
        state->setup_task.cb = proto_shell_setup_cb;
        state->setup_task.dir_fd = proto_fd.fd;
+       state->setup_task.log_prefix = iface->name;
        state->teardown_task.cb = proto_shell_teardown_cb;
        state->teardown_task.dir_fd = proto_fd.fd;
+       state->teardown_task.log_prefix = iface->name;
        state->proto_task.cb = proto_shell_task_cb;
        state->proto_task.dir_fd = proto_fd.fd;
+       state->proto_task.log_prefix = iface->name;
        state->handler = container_of(h, struct proto_shell_handler, proto);
 
        return &state->proto;