Não há aviso de indicador de bash após um processo bifurcado terminar

Question

Estou lendo o livro Programação Avançada no Ambiente Unix . Existe um programa de teste para testar a função fork . Funciona bem no meu Ubuntu. Mas o que eu confundo é que não há prompt de comando após o processo filho sair. O programa original é como o abaixo.

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>

int main()
{
  pid_t pid;
  if ((pid = fork()) < 0)
  {
    printf("fork error.\n");
    return 1;
  }
  else if (pid == 0)
  {
    if ((pid = fork()) < 0)
    {
      printf("fork error.\n");
      return 1;
    }
    else if (pid > 0)
    {
      printf("first child %d exit.\n", getpid());
      exit(0);
    }
    sleep(2);
    printf("second child %d has parent pid = %d.\n",getpid(),  getppid());
    exit(0);
  }

  printf("waitid %d.\n", pid);
  if (waitpid(pid, NULL, 0) != pid)
  {
    printf("waitid error.\n");
    return 1;
  }
  printf("process %d will exit..\n", getpid());

  exit(0);
}

Então eu corro

jerryli@ubuntu:~/project/unix$ ./p183.o
waitid 2256
first child 2256 exit.
process 2255 will exit..
jerryli@ubuntu:~/project/unix$ second child 2257 has parent pid = 1.

Após o prompt de linha acima, não há nada continuar. Eu espero que isso mostre

jerryli@ubuntu:~/project/unix$

Para ter o indicador acima, eu tenho que digitar Enter .

Você poderia saber o motivo? É porque o processo pai do segundo filho se torna o processo init do sistema?

    

Answer 1

fork inicia um processo em segundo plano. Quando o processo em primeiro plano (aquele que chama fork ) termina, o shell de chamada é notificado e mostra um novo prompt. O shell é o pai do processo original em primeiro plano; não é o pai de qualquer processo bifurcado.

A ordem em que o processo original e o processo bifurcado são executados não é fixa, mas é improvável que se desvie de maneira relevante devido ao atraso de 2 segundos. Em seu teste, acontece que a linha do tempo era:

1. fork o primeiro filho do processo original.
2. fork o segundo filho do primeiro filho.
3. O processo original imprime o waitid trace e inicia a chamada waitpid para aguardar o primeiro filho.
4. O primeiro filho imprime seu exit trace e sai.
5. O processo original é notificado da morte do processo filho e sua waitpid retornos de chamada.
6. O processo original imprime seu will exit trace.
7. O shell é notificado de que o processo original foi encerrado e imprime seu prompt.
8. Um pouco menos de dois segundos depois, a chamada sleep no segundo filho é concluída e o segundo filho imprime seu has parent trace.

O shell não recebe qualquer notificação do último evento, porque não é o pai do processo de morrer. De qualquer forma, ele já está sendo exibido e está aguardando que você digite um novo comando; não teria motivos para fazer nada (se você estivesse digitando um comando, isso poderia ser prejudicial).