Um zumbi pode ter órfãos? As crianças órfãs serão perturbadas por colher o zumbi?

Question

Pelo que entendi, um processo de zumbi morreu, mas ainda existe como espaço reservado na tabela de processos até que seu pai (ou init se o zumbi for um órfão) verifique seu status de saída.

E minha compreensão dos processos órfãos é que eles são processos que ainda estão vivos e em execução, mas cujos pais morreram.

Como um zumbi já está morto, seus filhos seriam considerados órfãos, não seriam? Eles seriam afetados por colher o zumbi? Especificamente, init os adotaria como seus filhos somente quando o zumbi fosse colhido, ou eles seriam adotados assim que o pai se tornasse um zumbi?

    

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.

Correto.

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

Correto.

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

Sim. Quando o pai morre, está morto. Com relação a seus filhos, não importa se os pais permanecem como zumbis: os filhos tornam-se órfãos no momento em que os pais morrem, e então perdem qualquer ligação com seus pais.

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?

Não, e o segundo, conforme acima.

    

Answer 2

Se os resultados experimentais servirem, parece que pelo menos systemd init irá colher os órfãos dos zumbis assim que possível:

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;
}

Em um terminal:

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

Em outro 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