[6]. O sistema mantém toda informação a respeito do processo em uma estrutura de dados chamada tabela de processos (process table ou PCB). Exatamente quais informações deverão ser salvas na tabela do processo?

Passo 1

O enunciado pergunta: “Exatamente quais informações deverão ser salvas na tabela do processo (process table / PCB)?”
O que precisa ser respondido: listar e explicar os campos essenciais que um sistema operacional mantém para cada processo na sua PCB, de forma que eu entenda para que serve cada campo e como ele é usado (por exemplo em criação, troca de contexto, bloqueio/desbloqueio e término de processo). Não há dados numéricos no enunciado nem figuras; é uma questão conceitual.

Passo 2

O que é a PCB e por que ela existe (explicação passo a passo e intuitiva).
  • A PCB (process control block) é a estrutura de dados do kernel que guarda “tudo” que o sistema precisa saber sobre um processo.
  • Por que existe: para que o kernel possa parar um processo, guardar o seu estado e depois retomar exatamente de onde parou; para organizar escalonamento, controlar I/O, segurança e contabilização.
  • Analogia rápida: pense na PCB como a “ficha” do processo — quando o processo é trocado de CPU para disco, a ficha acompanha tudo que é necessário para retornar ao mesmo ponto.

Passo 3

Campos de identificação (o mínimo que identifica e relaciona processos). Explique o que cada item significa e porque é útil.
  • Identificador do processo: \text{PID} — número único para referenciar o processo. Usado pelo kernel e por outros processos (ex.: kill).
  • Identificador do pai: \text{PPID} — quem criou o processo; importante para wait/collect e hierarquia de processos.
  • Grupo de processos / sessão / ID do usuário de sessão: usados para sinais em grupo, controle de terminal e gerenciamento de sessões.
  • Credenciais: \text{UID}, \text{GID} (e efetuados/effective IDs) — definem privilégios e autorização de acesso a recursos.

Passo 4

Estado do processo e informações de escalonamento (o que diz se ele está executando, pronto, bloqueado, etc.). Ensino como são usados.
  • Estado do processo: por exemplo \text{NEW}, \text{READY}, \text{RUNNING}, \text{BLOCKED}, \text{ZOMBIE}. O kernel consulta/atualiza este campo para decidir ações.
  • Prioridade e política de escalonamento: prioridade estática/dinâmica, política (FIFO, RR, CFS, real-time). Serve para que o escalonador escolha o próximo processo.
  • Contadores/estimativas de CPU: tempo de CPU gasto, fatia restante, contadores para algoritmos (ex.: burst estimado em SJF preditivo).
  • Ponteiros/listas do escalonador: links para filas (ready queue, wait queue). Esses ponteiros permitem inserir/remover o PCB rapidamente das filas.

Passo 5

Contexto de CPU (o que é necessário para retomar execução): explicar registro por registro na prática da prova.
  • Registradores da CPU: todos os registradores que o processo estava usando (incluindo registrador de propósito geral). Devem ser salvos/restaurados na troca de contexto.
  • Contador de programa: \text{PC} — endereço da próxima instrução a executar. Sem ele, não dá para retomar.
  • Ponteiro de pilha (user stack pointer) e outros apontadores de estado de execução.
  • Estado de flags/registradores de controle.
  • Observação prática: em uma troca de contexto o kernel executa rotina que salva esses campos na PCB e carrega os do próximo processo.

Passo 6

Informação de gerenciamento de memória (como o kernel encontra a memória do processo). Explique estruturas típicas e sua finalidade.
  • Informações de espaço de endereço: ponteiro para tabela de páginas (page table base) ou estrutura equivalente (ex.: \text{mm\_struct} no Linux).
  • Limites/segmentos: registros de limites/segmentos ou tabelas de segmentos (em arquiteturas que usam).
  • Ponteiros para bases do heap e da pilha (topo do heap, limites da stack) — usados em fork/exec e para checagem de violação de memória.
  • Mapeamentos de memória (mmap), lista de áreas de memória virtual — para carregar bibliotecas e arquivos mapeados.

Passo 7

Recursos de E/S e arquivos abertos — ensinar como o PCB participa em operações de I/O.
  • Tabela/vetor de descritores de arquivo abertos (file descriptors) — para cada entrada: ponteiro para estrutura de arquivo do kernel, flags (r/w), offset atual.
  • Dispositivo de controle: identificador do terminal controlador/TTY, se existir.
  • Ponteiros para operações assíncronas (callbacks), estado de I/O em andamento.
  • Informações sobre locks em dispositivos e exclusões relacionadas.

Passo 8

Sinais, handlers, IPC e relações entre processos (como processos se comunicam e reagem).
  • Máscara de sinais e tabela de handlers: quais sinais estão bloqueados, quais funções tratarão cada sinal, e comportamento por omissão.
  • Estruturas de IPC: endpoints, filas de mensagens, semáforos, descritores de sockets ou referências a objetos IPC — se o kernel mantém por-processo.
  • Lista de filhos / lista de processos relacionados: facilita wait/wakeup e administração.

Passo 9

Contabilização, limites e informações administrativas (útil para auditoria e política). Explique exemplos.
  • Estatísticas de tempo: tempo usuário, tempo sistema, last CPU, número de trocas de contexto, número de page faults.
  • Limites e quotas: limites de recursos (ulimit) — memória máxima, número máximo de arquivos abertos, tempo CPU permitido.
  • Contadores de uso de recursos e informações de billing/accounting para logs.

Passo 10

Campos do kernel e outros detalhes práticos (o “manual do kernel” que não aparece no user-space).
  • Ponteiro para pilha de kernel do processo (kernel stack) — cada processo costuma ter sua stack no kernel para chamadas do sistema.
  • Flags do processo e estado interno do kernel (ex.: marcas de tracers/ptrace, traced, killed).
  • Código de saída / status de término — usado quando o processo morre e o pai chama wait.
  • Estruturas internas: locks do PCB, relógios de espera, wait channel, e ponteiros para estruturas específicas do SO (ex.: estruturas do scheduler).

Passo 11

Como responder em prova — versão objetiva e curta (modelo de resposta) e dicas do que NÃO esquecer.
  • Dica prática: comece listando identificação (PID, PPID, UID), depois estado e escalonamento (estado, prioridade), depois contexto (PC, registradores), depois memória (tabela de páginas), depois I/O (descritores abertos), depois sinais/IPCs, depois accounting/limites e por fim campos kernel/ponteiros. Essa ordem mostra organização mental e cobre os pontos importantes.
  • Evite só listar nomes: sempre explique brevemente a função de cada campo (uma linha cada) para ganhar pontos extras.

Passo 12

Resumo final curto do que considerar “obrigatório” na PCB — o que tipicamente o professor espera ver como resposta mínima (útil para checar rapidamente antes da prova).
  • Campos essenciais mínimos: identificação (PID/PPID/UID), estado do processo, contexto de CPU (PC e registradores), ponteiros de memória (tabela de páginas), descriptors de arquivos abertos, prioridades/infos de escalonador, e informações de contabilização/limites. Se listar esses e explicar uma linha cada, já cobre a maioria das provas.

Resposta

Identificação: PID, PPID, UID/GID (credenciais), grupo de processo e sessão.
Estado e escalonamento: estado do processo (NEW/READY/RUNNING/BLOCKED/ZOMBIE), prioridade/política de escalonamento, contadores/estimativas de CPU, ponteiros para filas do escalonador.
Contexto de CPU: contador de programa (PC), registradores gerais e de propósito especial, ponteiro de pilha (user SP), flags — tudo necessário para troca de contexto.
Gerenciamento de memória: ponteiro para tabela de páginas / estrutura do espaço de endereço, limites/segmentos, lista de mapeamentos (mmap), ponteiros heap/stack.
E/S e arquivos: tabela de descritores de arquivo abertos (com offsets e flags), dispositivo controlador/TTY, informações sobre I/O em curso.
Sinais e IPC: máscara de sinais e handlers, referências a endpoints IPC/filas/semáforos/sockets.
Contabilização e limites: tempo de CPU (user/system), page faults, contadores de I/O, limites de recursos (quotas/ulimit).
Campos do kernel e administrativos: ponteiro para kernel stack, flags do processo (traced/killed), código de saída/status, ponteiros para filhos/parent/next, locks internos e outras estruturas específicas do SO.

Exercícios relacionados