keep track of all running child processes in one place

diff --git a/main.c b/main.c
index 5770782f1646498c29be6efd3d45c67be3491f63..352519de5d32cc4b2baa4029c983442b3975a3f2 100644 (file)
--- a/main.c
+++ b/main.c
@@ -14,6 +14,61 @@ unsigned int debug_mask = 0;
 const char *main_path = DEFAULT_MAIN_PATH;
 const char *resolv_conf = DEFAULT_RESOLV_CONF;
 static char **global_argv;
+static struct list_head process_list = LIST_HEAD_INIT(process_list);
+
+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);
+       return np->cb(np, ret);
+}
+
+int
+netifd_start_process(const char **argv, char **env, int dir_fd, struct netifd_process *proc)
+{
+       int pid;
+
+       netifd_kill_process(proc);
+
+       if ((pid = fork()) < 0)
+               return -1;
+
+       if (!pid) {
+               if (env) {
+                       while (*env) {
+                               putenv(*env);
+                               env++;
+                       }
+               }
+               if (dir_fd >= 0)
+                       fchdir(dir_fd);
+               execvp(argv[0], (char **) argv);
+               exit(127);
+       }
+
+       if (pid < 0)
+               return -1;
+
+       proc->uloop.cb = netifd_process_cb;
+       proc->uloop.pid = pid;
+       uloop_process_add(&proc->uloop);
+       list_add_tail(&proc->list, &process_list);
+
+       return 0;
+}
+
+void
+netifd_kill_process(struct netifd_process *proc)
+{
+       if (!proc->uloop.pending)
+               return;
+
+       kill(proc->uloop.pid, SIGTERM);
+       uloop_process_delete(&proc->uloop);
+       list_del(&proc->list);
+}
 
 static void netifd_do_restart(struct uloop_timeout *timeout)
 {

diff --git a/netifd.h b/netifd.h
index d034e7aef1e6018c6d5dd66d8a3491e44b145d59..5eeb5e25b291be5317151c496c78b2b62d96ede9 100644 (file)
--- a/netifd.h
+++ b/netifd.h
@@ -48,6 +48,15 @@ static inline void no_debug(int level, const char *fmt, ...)
 {
 }
 
+struct netifd_process {
+       struct list_head list;
+       struct uloop_process uloop;
+       void (*cb)(struct netifd_process *, int ret);
+};
+
+int netifd_start_process(const char **argv, char **env, int dir_fd, struct netifd_process *proc);
+void netifd_kill_process(struct netifd_process *proc);
+
 struct device;
 struct interface;
 

diff --git a/proto-shell.c b/proto-shell.c
index bc74de9a51eab2a2fb8c112155968eec593bddf5..0e1412ba53bda1e40839eef264ce67261fe32842 100644 (file)
--- a/proto-shell.c
+++ b/proto-shell.c
@@ -36,62 +36,21 @@ struct proto_shell_state {
        struct device_user l3_dev;
 
        struct uloop_timeout setup_timeout;
-       struct uloop_process setup_task;
-       struct uloop_process teardown_task;
+       struct netifd_process setup_task;
+       struct netifd_process teardown_task;
        bool teardown_pending;
        bool teardown_wait_task;
 
-       struct uloop_process proto_task;
+       struct netifd_process proto_task;
 };
 
-static void
-kill_process(struct uloop_process *proc)
-{
-       if (!proc->pending)
-               return;
-
-       kill(proc->pid, SIGTERM);
-       uloop_process_delete(proc);
-}
-
-static int
-start_process(const char **argv, char **env, struct uloop_process *proc)
-{
-       int pid;
-
-       kill_process(proc);
-
-       if ((pid = fork()) < 0)
-               return -1;
-
-       if (!pid) {
-               if (env) {
-                       while (*env) {
-                               putenv(*env);
-                               env++;
-                       }
-               }
-               fchdir(proto_fd);
-               execvp(argv[0], (char **) argv);
-               exit(127);
-       }
-
-       if (pid < 0)
-               return -1;
-
-       proc->pid = pid;
-       uloop_process_add(proc);
-
-       return 0;
-}
-
 static int
 proto_shell_handler(struct interface_proto_state *proto,
                    enum interface_proto_cmd cmd, bool force)
 {
        struct proto_shell_state *state;
        struct proto_shell_handler *handler;
-       struct uloop_process *proc;
+       struct netifd_process *proc;
        const char *argv[6];
        const char *action;
        char *config;
@@ -106,9 +65,9 @@ proto_shell_handler(struct interface_proto_state *proto,
        } else {
                action = "teardown";
                proc = &state->teardown_task;
-               if (state->setup_task.pending && !state->teardown_wait_task) {
+               if (state->setup_task.uloop.pending && !state->teardown_wait_task) {
                        uloop_timeout_set(&state->setup_timeout, 1000);
-                       kill(state->setup_task.pid, SIGTERM);
+                       kill(state->setup_task.uloop.pid, SIGTERM);
                        state->teardown_pending = true;
                        return 0;
                }
@@ -127,7 +86,7 @@ proto_shell_handler(struct interface_proto_state *proto,
                argv[i++] = proto->iface->main_dev.dev->ifname;
        argv[i] = NULL;
 
-       ret = start_process(argv, NULL, proc);
+       ret = netifd_start_process(argv, NULL, proto_fd, proc);
        free(config);
 
        return ret;
@@ -139,11 +98,11 @@ proto_shell_setup_timeout_cb(struct uloop_timeout *timeout)
        struct proto_shell_state *state;
 
        state = container_of(timeout, struct proto_shell_state, setup_timeout);
-       kill(state->setup_task.pid, SIGKILL);
+       kill(state->setup_task.uloop.pid, SIGKILL);
 }
 
 static void
-proto_shell_setup_cb(struct uloop_process *p, int ret)
+proto_shell_setup_cb(struct netifd_process *p, int ret)
 {
        struct proto_shell_state *state;
 
@@ -156,7 +115,7 @@ proto_shell_setup_cb(struct uloop_process *p, int ret)
 }
 
 static void
-proto_shell_teardown_cb(struct uloop_process *p, int ret)
+proto_shell_teardown_cb(struct netifd_process *p, int ret)
 {
        struct proto_shell_state *state;
 
@@ -165,7 +124,7 @@ proto_shell_teardown_cb(struct uloop_process *p, int ret)
        if (state->teardown_wait_task)
                return;
 
-       kill_process(&state->proto_task);
+       netifd_kill_process(&state->proto_task);
 
        if (state->l3_dev.dev)
                device_remove_user(&state->l3_dev);
@@ -174,7 +133,7 @@ proto_shell_teardown_cb(struct uloop_process *p, int ret)
 }
 
 static void
-proto_shell_task_cb(struct uloop_process *p, int ret)
+proto_shell_task_cb(struct netifd_process *p, int ret)
 {
        struct proto_shell_state *state;
        bool teardown_wait_task;
@@ -183,7 +142,7 @@ proto_shell_task_cb(struct uloop_process *p, int ret)
 
        teardown_wait_task = state->teardown_wait_task;
        state->teardown_wait_task = false;
-       if (state->teardown_pending || state->teardown_task.pending)
+       if (state->teardown_pending || state->teardown_task.uloop.pending)
                return;
 
        if (teardown_wait_task) {
@@ -442,7 +401,7 @@ proto_shell_run_command(struct proto_shell_state *state, struct blob_attr **tb)
        if (!fill_string_list(tb[NOTIFY_ENV], env, ARRAY_SIZE(env)))
                goto error;
 
-       start_process((const char **) argv, (char **) env, &state->proto_task);
+       netifd_start_process((const char **) argv, (char **) env, proto_fd, &state->proto_task);
 
        return 0;
 
@@ -461,8 +420,8 @@ proto_shell_kill_command(struct proto_shell_state *state, struct blob_attr **tb)
        if (signal > 31)
                signal = SIGTERM;
 
-       if (state->proto_task.pending) {
-               kill(state->proto_task.pid, signal);
+       if (state->proto_task.uloop.pending) {
+               kill(state->proto_task.uloop.pid, signal);
                state->teardown_wait_task = true;
        }