Arquitetura e Gerenciamento de Processos no Linux

No contexto de sistemas operacionias, um processo pode ser definido como uma instância em execução de um programa. Sob a perspectiva do kernel, ele atua como a entidade fundamental para a alocação de recursos, como tempo de CPU e espaço em memória. Tecnicamente, um processo é composto pela estrutura de dados de gerenciamento do kernel (como a task_struct e tabelas de páginas) somada ao código e dados do programa em si.

A Estrutura task_struct

A task_struct é o descritor de processo carregado na RAM, contendo todas as metainformações necessárias para o gerenciamento da tarefa. Seus principais campos incluem:

• Identificadores: Valores únicos para distinguir o processo de outros no sistema.
• Estado Atual: Indica se o processo está executando, dormindo, parado ou morto, além de códigos de saída.
• Prioridade: Define a precedência na obtenção de recursos em relação a outras tarefas.
• Contador de Programa: Armazena o endereço da próxima instrução a ser executada.
• Ponteiros de Memória: Referências para os segmentos de código, dados e áreas de memória compartilhada.
• Contexto de Hardware: Dados dos registradores da CPU salvos durante uma troca de contexto.
• Estado de E/S: Lista de arquivos abertos e dispositivos de entrada/saída atribuídos.
• Dados de Contabilidade: Métricas de uso de CPU, limites de tempo e informações de auditoria.

Identificação e Manipulação de Processos (PID)

Cada processo recebe um Identificador de Processo (PID) único. Para inspecionar as propriedades das tarefas em execução, é possível utilizar utilitários de linha de comando ou inspecionar o sistema de arquivos virtual /proc.

# Listar processos e filtrar por nome
ps aux | grep minha_tarefa

# Inspecionar o diretório virtual de processos
ls /proc

Como o /proc é dinâmico, ele reflete apenas o estado em tempo real do sistema. Se um processo for encerrado, seu diretório correspondente desaparecerá imediatamente.

Obtenção de PIDs via Código

Programas em C podem consultar seus próprios identificadores e de seus processos pais utilizando as chamadas de sistema da biblioteca padrão:

#include <stdio.h>
#include <unistd.h>

int main(void) {
    pid_t meu_pid = getpid();
    pid_t pid_pai = getppid();
    
    printf("PID do processo atual: %d\n", meu_pid);
    printf("PID do processo progenitor: %d\n", pid_pai);
    
    return 0;
}

Para forçar o encerramento de uma tarefa travada, utiliza-se o comando kill com o sinal SIGKILL (9):

kill -9 <PID_ALVO>

Criação de Processos: A Chamada fork()

A criação de novos processos no Linux ocorre predominantemente através da chamada de sistema fork(). Esta função possui um comportamento singular: ela retorna duas vezes.

• Retorno 0: Indica que a execução está ocorrendo no processo filho.
• Retorno > 0: Indica que a execução está no processo pai, e o valor retornado é o PID do filho.

O kernel utiliza o mecanismo de Copy-on-Write (Cópia sobre Escrita). Inicialmente, pai e filho compartilham os mesmos espaços de memória física para o código e dados. A duplicação real da memória só ocorre quando um dos processos tenta modificar um valor.

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

int main(void) {
    int variavel_compartilhada = 10;
    pid_t id_filho = fork();

    if (id_filho < 0) {
        perror("Erro no fork");
        exit(EXIT_FAILURE);
    } else if (id_filho == 0) {
        // Escopo do Filho
        variavel_compartilhada = 99;
        printf("[Filho] PID: %d | Variavel alterada para: %d\n", getpid(), variavel_compartilhada);
    } else {
        // Escopo do Pai
        sleep(1); // Pausa para garantir que o filho execute primeiro
        printf("[Pai]  PID: %d | Variavel manteve-se: %d\n", getpid(), variavel_compartilhada);
    }

    return 0;
}

Ao executar o código acima, nota-se que a alteração da variável no filho não afeta a variável no pai, comprovando a independência dos espaços de dados após a escrita.

Estados de Execução de um Processo

O kernel rastreia o ciclo de vida de cada tarefa através de flags de estado. Os principais estados no Linux são:

R (Running / Runnable)

O processo está pronto para executar e aguarda na fila de execução (runqueue) ou está atualmente utilizando a CPU. Como a CPU é um recurso finito, o escalonador divide o tempo em fatias (time slices ou quantum, geralmente em torno de 10ms). Um processo não executa até o fim; ele é preemptado para dar lugar a outras tarefas, garantindo a concorrência.

S e D (Sleeping States)

• S (Interruptible Sleep): O processo está bloqueado aguardando um evento ou recurso (como E/S ou um sinal). Ele pode ser interrompido e acordado por sinais.
• D (Uninterruptible Sleep): Estado de espera crítica, geralmente por operações de E/S de baixo nível no disco. O processo não pode ser interrompido por sinais. Se o kernel matasse um processo em estado D durante uma escrita crítica no disco, ocorreria corrupção de dados. Processos em estado D não podem ser mortos com kill -9; a única solução em casos de travamento é reiniciar o sistema.

T e t (Stopped / Traced)

• T (Stopped): O processo foi suspenso, geralmente por receber um sinal SIGSTOP ou SIGTSTP.
• t (Traced): O processo está sendo rastreado por um depurador (como o gdb) e parou em um breakpoint.

Controle via sinais:

kill -19 <PID>  # Pausa o processo (SIGSTOP)
kill -18 <PID>  # Retoma o processo (SIGCONT)

Z (Zombie) e X (Dead)

• Z (Zombie): O processo terminou sua execução e liberou a maior parte de seus recursos, mas sua entrada na task_struct é mantida para que o processo pai possa ler seu status de saída (código de retorno). Se o pai não chamar wait() ou waitpid(), o processo filho permanece como zumbi.
• X (Dead): Estado transitório onde o processo foi completamente removido da tabela de processos e todos os recursos foram liberados.

Processos Órfãos

Se um processo pai termina antes de seu filho, o filho se torna órfão. Para evitar que processos órfãos fiquem sem supervisão e gerem zumbis permanentemente, o kernel reatribui a paternidade desses processos para o procesos init (PID 1) ou systemd, que periodicamente executa wait() para limpá-los corretamente.

Gerenciamento de Prioridades

A prioridade determina a ordem em que o escalonador do kernel concede tempo de CPU aos processos. No Linux, isso é gerenciado por dois valores principais:

• PRI (Priority): A prioridade dinâmica real do processo. Quanto menor o valor, maior a prioridade.
• NI (Nice): Um valor de ajuste fornecido pelo usuário para influenciar o PRI.

A relação básica é: PRI (novo) = PRI (antigo) + NI. O valor de nice varia de -20 (maior prioridade) a 19 (menor prioridade), com um total de 40 níveis. A prioridade base padrão no Linux é 80.

Nota: Prioridade refere-se à ordem de acesso a recursos já garantidos, enquanto permissões (como root) referem-se à capacidade de acessar ou modificar o sistema.

Alterando Prioridades em Tempo de Execução

Para modificar o valor de nice de um processo ativo, pode-se utilizar o monitor de sistemas top:

1. Execute o comando top no terminal.
2. Pressione a tecla r para renice.
3. Insira o PID do processo alvo.
4. Digite o novo valor de NI desejado (respeitando os limites de -20 a 19, lembrando que apenas o root pode definir valores negativos).