Can a zombie have orphans? Will the orphan children be disturbed by reaping the zombie?

Question

As I understand it, a zombie process has died but still exists as a placeholder in the process table until its parent (or init if the zombie is itself an orphan) checks its exit status.

And my understanding of orphan processes is they are processes that are still alive and running but whose parent has died.

Since a zombie is already dead, its children would be considered orphans, wouldn't they? Would they be affected be reaping the zombie? Specifically, would init adopt them as its children only once the zombie was reaped, or would they be adopted as soon as the parent became a zombie?

Answer 1

As I understand it, a zombie process has died but still exists as a placeholder in the process table until its parent (or init if the zombie is itself an orphan) checks its exit status.

Correct.

And my understanding of orphan processes is they are processes that are still alive and running but whose parent has died.

Correct.

Since a zombie is already dead, its children would be considered orphans, wouldn't they?

Yes. When the parent dies, it's dead. With respect to its children, it doesn't matter whether the parent stays on as a zombie: the children become orphans at the time the parent dies, and then they lose any connection with their parent.

Would they be affected be reaping the zombie? Specifically, would init adopt them as its children only once the zombie was reaped, or would they be adopted as soon as the parent became a zombie?

No, and the latter, as per above.

Answer 2

If experimental results will do, it appears at least systemd init will reap the zombie's orphans as soon as it can:

foo.c:

#include <unistd.h>

int main(void)
{
    pid_t child = fork();
    if (child < 0)
        return -1;
    if (child == 0)
    {
        pid_t grand_child = fork();
        if (grand_child < 0)
            return -1;
        if (grand_child == 0)
            sleep (1000);
        else
            return 0;
    }
    else
        sleep (1000);
    return 0;
}

In one terminal:

$ gcc -o foo foo.c
$ ./foo

In another terminal:

$ pgrep foo                         
25548
25549
25550
$ pstree -pa 25548
foo,25548
  └─(foo,25549)
$ pstree -psa 25550
systemd,1
  └─foo,25550
$ ps -o stat,pid -p $(pgrep -d, foo)
STAT   PID
S+   25548
Z+   25549
S+   25550