Deal with inheriting traced processes.

[peadar]

If a debugger exits and leaves its child traced, then init inherits the
tracing of the process as well as becoming its parent.

Change our wait behaviour to detach from such children, and forward them
the signal that caused them to be stopped.

This stops us accumulating zombies if a debugger doesn't clean up on exit

[Snaipe]

Isn't the data arg of ptrace ignored with PTRACE_DETACH? what's the purpose of passing in WSTOPSIG(status)?

[peadar]

No - "addr" is ignored. "data" is the signal you want to send to the target.

       PTRACE_DETACH
              Restart the stopped tracee as for PTRACE_CONT, but first detach from it.  Under Linux, a tracee can be detached in this way regardless  of
              which method was used to initiate tracing.  (addr is ignored.)

And:

       PTRACE_CONT
              Restart the stopped tracee process.  If data is nonzero, it is interpreted as the number of a signal to be delivered to the tracee; other‐
              wise, no signal is delivered.  Thus, for example, the tracer can control whether a signal sent to the tracee is delivered or  not.   (addr
              is ignored.)

[peadar]

BTW: I checked this because dumb-init's behaviour is to abort when this happens, killing the container.
It appears systemd's init also leaves the process attached to the init, and renders it unkillable except with kill -9. So if you want to discard this, it'll be no worse than systemd.
Here's what I used to repro:

#include <assert.h>
#include <stdarg.h>
#include <errno.h>
#include <iostream>
#include <unistd.h>
#include <err.h>
#include <string.h>

#include <sys/ptrace.h>
#include <sys/wait.h>

void
okOrExit(int value, int expected, const char *reason, ...) {
   if (value != expected) {
      va_list args; va_start(args, reason);
      verr(1, reason, args);
   }
}

void sighandle(int) {}
static int child() {
   okOrExit(ptrace(PTRACE_TRACEME, 0, 0), 0, "ptrace(PTRACE_TRACEME) failed");      
   signal(SIGALRM, sighandle);
   okOrExit(alarm(4), 0, "alarm failed");
   std::clog << "pausing...\n";
   int rc = pause();
   std::clog << "pause returned " << rc << "/" << strerror(errno) << std::endl;     
   return 0;
}

static int parent(pid_t childpid) {
   int status;
   okOrExit(ptrace(PTRACE_ATTACH, childpid, 0, 0), 0, "ptrace attach failed");      
   int rc = waitpid(childpid, &status, 0);
   okOrExit(rc, childpid, "waitpid for %d got %d", childpid, rc);
   std::clog << "child continued\n";
   return 0;
}

int main() {
   pid_t childpid;
   switch (childpid = fork()) {
      case  0: return child();
      default: return parent(childpid);
      case -1: return err(1, "fork failed"), 1;
   } 
}