How to make child process die after parent exits?

Question

Suppose I have a process which spawns exactly one child process. Now when the parent process exits for whatever reason (normally or abnormally, by kill, ^C, assert failure or anything else) I want the child process to die. How to do that correctly?

---

Some similar question on stackoverflow:

• (asked earlier) How can I cause a child process to exit when the parent does?
• (asked later) Are child processes created with fork() automatically killed when the parent is killed?

---

Some similar question on stackoverflow for Windows:

• How do I automatically destroy child processes in Windows?
• Kill child process when parent process is killed

Answer 1

I managed to do a portable, non-polling solution with 3 processes by abusing terminal control and sessions. This is mental masturbation, but works.

The trick is:

• process A is started
• process A creates a pipe P (and never reads from it)
• process A forks into process B
• process B creates a new session
• process B allocates a virtual terminal for that new session
• process B installs SIGCHLD handler to die when the child exits
• process B sets a SIGPIPE handler
• process B forks into process C
• process C does whatever it needs (e.g. exec()s the unmodified binary or runs whatever logic)
• process B writes to pipe P (and blocks that way)
• process A wait()s on process B and exits when it dies

That way:

• if process A dies: process B gets a SIGPIPE and dies
• if process B dies: process A's wait() returns and dies, process C gets a SIGHUP (because when the session leader of a session with a terminal attached dies, all processes in the foreground process group get a SIGHUP)
• if process C dies: process B gets a SIGCHLD and dies, so process A dies

Shortcomings:

• process C can't handle SIGHUP
• process C will be run in a different session
• process C can't use session/process group API because it'll break the brittle setup
• creating a terminal for every such operation is not the best idea ever

Answer 2

Does the child process have a pipe to/from the parent process? If so, you'd receive a SIGPIPE if writing, or get EOF when reading - these conditions could be detected.

Answer 3

If you send a signal to the pid 0, using for instance

kill(0, 2); /* SIGINT */

that signal is sent to the entire process group, thus effectively killing the child.

You can test it easily with something like:

(cat && kill 0) | python

If you then press ^D, you'll see the text "Terminated" as an indication that the Python interpreter have indeed been killed, instead of just exited because of stdin being closed.

Answer 4

I have achieved this in the past by running the "original" code in the "child" and the "spawned" code in the "parent" (that is: you reverse the usual sense of the test after fork()). Then trap SIGCHLD in the "spawned" code...

May not be possible in your case, but cute when it works.

Answer 5

As other people have pointed out, relying on the parent pid to become 1 when the parent exits is non-portable. Instead of waiting for a specific parent process ID, just wait for the ID to change:

pit_t pid = getpid();
switch (fork())
{
    case -1:
    {
        abort(); /* or whatever... */
    }
    default:
    {
        /* parent */
        exit(0);
    }
    case 0:
    {
        /* child */
        /* ... */
    }
}

/* Wait for parent to exit */
while (getppid() != pid)
    ;

Add a micro-sleep as desired if you don't want to poll at full speed.

This option seems simpler to me than using a pipe or relying on signals.

Answer 6

I think a quick and dirty way is to create a pipe between child and parent. When parent exits, children will receive a SIGPIPE.