fork(), wait(), família exec e ciclo de vida do processo
Um processo pode criar outro como uma cópia de si mesmo e, em seguida, substituir o programa executado pelo novo processo. Esse mecanismo é a base de como o shell executa comandos, servidores criam processos de trabalho (workers), pipelines funcionam e processos pais controlam seus filhos.
Imagine que o shell precise executar outro programa, como ls. Se o próprio processo do shell fosse substituído diretamente pelo ls, ele deixaria de existir quando o comando terminasse.
O Unix separou a criação de processo em duas operações diferentes:
flowchart TD
subgraph "Exec"
a("exec") --> b("troca o programa dentro do processo atual")
end
subgraph "Fork"
c("fork") --> d("cria um novo processo copiando o atual")
end
O shell faz, de forma simplificada, o seguinte:
- O shell chama
fork(). - O processo pai continua executando o shell.
- O processo filho chama uma função da família
execpara executarls.
Depois, o processo pai espera o filho terminar com wait() ou waitpid().
Fork
Conceitualmente, fork() cria um processo filho a partir do processo pai. O filho nasce muito parecido com o pai:
- O mesmo código.
- Cópias das variáveis existentes no momento de
fork(). - Descritores correspondentes aos mesmos arquivos abertos.
- O mesmo diretório de trabalho atual.
- Cópias das mesmas variáveis de ambiente.
- Continuação da execução logo após
fork().
Mas são processos diferentes, pois cada um tem:
- PID próprio.
- Espaço de memória virtual próprio.
- Estado próprio.
- Fluxo de execução próprio.
Quando fork() é bem-sucedida, pai e filho continuam a partir da instrução seguinte. No pai, a função retorna o PID do filho; no filho, retorna 0. Em caso de erro, somente o processo pai continua, e a função retorna -1.
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
int main(void) {
pid_t pid = fork();
if (pid == -1) {
perror("fork");
return 1;
}
if (pid == 0) {
printf(
"Sou o processo filho. Meu PID é %ld e o PID do meu pai é %ld.\n",
(long)getpid(),
(long)getppid()
);
} else {
printf(
"Sou o processo pai. Meu PID é %ld e criei o filho %ld.\n",
(long)getpid(),
(long)pid
);
}
return 0;
}
A ordem das mensagens pode mudar, pois, depois de fork(), pai e filho são processos diferentes. O escalonador do kernel decide qual deles executará primeiro.
Exec
As funções da família exec substituem o programa executado pelo processo atual. Elas não criam outro processo; em caso de sucesso, o PID é preservado e a imagem do programa é substituída. Descritores sem a opção FD_CLOEXEC permanecem abertos.
Antes:
text -> código do programa antigo
data -> variáveis globais do programa antigo
heap -> alocações do programa antigo
stack -> pilha do programa antigo
Depois do exec():
text -> código do novo programa
data -> variáveis globais do novo programa
heap -> novo heap
stack -> nova pilha inicial
É importante saber que uma função da família exec não retorna em caso de sucesso, pois o programa anterior foi substituído. A instrução seguinte somente é executada se ocorrer um erro.
#include <stdio.h>
#include <unistd.h>
int main(void) {
printf("Antes de execlp().\n");
fflush(stdout);
execlp("ls", "ls", "-l", NULL);
perror("execlp");
return 1;
}
Wait
Quando um processo filho termina, o pai precisa coletar seu resultado. O wait() serve para:
- Esperar um filho terminar.
- Coletar seu status de saída.
- Remover a entrada do processo zumbi da tabela mantida pelo kernel.
Processo zumbi
Um processo zumbi não está mais em execução e não consome tempo de CPU. Seus principais recursos já foram liberados, mas uma entrada mínima, com informações sobre o término, permanece na tabela de processos.
Essa entrada permanece até que o pai colete o estado do filho ou termine; nesse último caso, outro processo do sistema adota e coleta o filho.
Corrigindo o código:
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
int main(void) {
pid_t pid = fork();
if (pid == -1) {
perror("fork");
return 1;
}
if (pid == 0) {
printf("Filho %ld terminando.\n", (long)getpid());
return 0;
} else {
int status;
if (waitpid(pid, &status, 0) == -1) {
perror("waitpid");
return 1;
}
printf("Pai coletou o filho.\n");
}
return 0;
}
Agora a entrada do filho é coletada, e ele não permanece como zumbi.
Usando waitpid(), conseguimos escolher qual filho esperar.