run-command: optionally kill children on exit

When we spawn a helper process, it should generally be done
and finish_command called before we exit. However, if we
exit abnormally due to an early return or a signal, the
helper may continue to run in our absence.

In the best case, this may simply be wasted CPU cycles or a
few stray messages on a terminal. But it could also mean a
process that the user thought was aborted continues to run
to completion (e.g., a push's pack-objects helper will
complete the push, even though you killed the push process).

This patch provides infrastructure for run-command to keep
track of PIDs to be killed, and clean them on signal
reception or input, just as we do with tempfiles. PIDs can
be added in two ways:

1. If NO_PTHREADS is defined, async helper processes are
automatically marked. By definition this code must be
ready to die when the parent dies, since it may be
implemented as a thread of the parent process.

2. If the run-command caller specifies the "clean_on_exit"
option. This is not the default, as there are cases
where it is OK for the child to outlive us (e.g., when
spawning a pager).

PIDs are cleared from the kill-list automatically during
wait_or_whine, which is called from finish_command and
finish_async.

Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Clemens Buchacher <drizzd@aon.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/run-command.c b/run-command.c
index 1c5104388429e50722769358d5d89948c55bb3aa..0204aaf7e8d6465900060a17552e26c74d2df520 100644 (file)
--- a/run-command.c
+++ b/run-command.c
@@ -1,8 +1,66 @@
 #include "cache.h"
 #include "run-command.h"
 #include "exec_cmd.h"
 #include "cache.h"
 #include "run-command.h"
 #include "exec_cmd.h"

+#include "sigchain.h"

 #include "argv-array.h"
 
 #include "argv-array.h"
 

+struct child_to_clean {
+       pid_t pid;
+       struct child_to_clean *next;
+};
+static struct child_to_clean *children_to_clean;
+static int installed_child_cleanup_handler;
+
+static void cleanup_children(int sig)
+{
+       while (children_to_clean) {
+               struct child_to_clean *p = children_to_clean;
+               children_to_clean = p->next;
+               kill(p->pid, sig);
+               free(p);
+       }
+}
+
+static void cleanup_children_on_signal(int sig)
+{
+       cleanup_children(sig);
+       sigchain_pop(sig);
+       raise(sig);
+}
+
+static void cleanup_children_on_exit(void)
+{
+       cleanup_children(SIGTERM);
+}
+
+static void mark_child_for_cleanup(pid_t pid)
+{
+       struct child_to_clean *p = xmalloc(sizeof(*p));
+       p->pid = pid;
+       p->next = children_to_clean;
+       children_to_clean = p;
+
+       if (!installed_child_cleanup_handler) {
+               atexit(cleanup_children_on_exit);
+               sigchain_push_common(cleanup_children_on_signal);
+               installed_child_cleanup_handler = 1;
+       }
+}
+
+static void clear_child_for_cleanup(pid_t pid)
+{
+       struct child_to_clean **last, *p;
+
+       last = &children_to_clean;
+       for (p = children_to_clean; p; p = p->next) {
+               if (p->pid == pid) {
+                       *last = p->next;
+                       free(p);
+                       return;
+               }
+       }
+}
+

 static inline void close_pair(int fd[2])
 {
        close(fd[0]);
 static inline void close_pair(int fd[2])
 {
        close(fd[0]);


@@ -130,6 +188,9 @@ static int wait_or_whine(pid_t pid, const char *argv0, int silent_exec_failure)
        } else {
                error("waitpid is confused (%s)", argv0);
        }
        } else {
                error("waitpid is confused (%s)", argv0);
        }

+
+       clear_child_for_cleanup(pid);
+

        errno = failed_errno;
        return code;
 }
        errno = failed_errno;
        return code;
 }


@@ -292,6 +353,8 @@ int start_command(struct child_process *cmd)
        if (cmd->pid < 0)
                error("cannot fork() for %s: %s", cmd->argv[0],
                        strerror(failed_errno = errno));
        if (cmd->pid < 0)
                error("cannot fork() for %s: %s", cmd->argv[0],
                        strerror(failed_errno = errno));

+       else if (cmd->clean_on_exit)
+               mark_child_for_cleanup(cmd->pid);

 
        /*
         * Wait for child's execvp. If the execvp succeeds (or if fork()
 
        /*
         * Wait for child's execvp. If the execvp succeeds (or if fork()


@@ -312,6 +375,7 @@ int start_command(struct child_process *cmd)
                cmd->pid = -1;
        }
        close(notify_pipe[0]);
                cmd->pid = -1;
        }
        close(notify_pipe[0]);

+

 }
 #else
 {
 }
 #else
 {


@@ -356,6 +420,8 @@ int start_command(struct child_process *cmd)
        failed_errno = errno;
        if (cmd->pid < 0 && (!cmd->silent_exec_failure || errno != ENOENT))
                error("cannot spawn %s: %s", cmd->argv[0], strerror(errno));
        failed_errno = errno;
        if (cmd->pid < 0 && (!cmd->silent_exec_failure || errno != ENOENT))
                error("cannot spawn %s: %s", cmd->argv[0], strerror(errno));

+       if (cmd->clean_on_exit && cmd->pid >= 0)
+               mark_child_for_cleanup(cmd->pid);

 
        if (cmd->env)
                free_environ(env);
 
        if (cmd->env)
                free_environ(env);


@@ -540,6 +606,8 @@ int start_async(struct async *async)
                exit(!!async->proc(proc_in, proc_out, async->data));
        }
 
                exit(!!async->proc(proc_in, proc_out, async->data));
        }
 

+       mark_child_for_cleanup(async->pid);
+

        if (need_in)
                close(fdin[0]);
        else if (async->in)
        if (need_in)
                close(fdin[0]);
        else if (async->in)

diff --git a/run-command.h b/run-command.h
index 56491b9f2344541c02bd0da2928a535f11193bd8..2a6946668b6dd2af3ed3f787ceed77674f86cf0c 100644 (file)
--- a/run-command.h
+++ b/run-command.h
@@ -38,6 +38,7 @@ struct child_process {
        unsigned silent_exec_failure:1;
        unsigned stdout_to_stderr:1;
        unsigned use_shell:1;
        unsigned silent_exec_failure:1;
        unsigned stdout_to_stderr:1;
        unsigned use_shell:1;

+       unsigned clean_on_exit:1;

        void (*preexec_cb)(void);
 };
 
        void (*preexec_cb)(void);
 };