[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.
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:
— número único para referenciar o processo. Usado pelo kernel e por outros processos (ex.: kill). - Identificador do pai:
— 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:
, (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
, , , , . 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:
— 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.:
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.
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.