Resumo Detalhado_Sistemas Operacionais

Prévia do material em texto

Tema 2 - Conceitos Básicos de 
Sistemas Operacionais 
 
Este tema aborda os fundamentos dos sistemas operacionais (SO), desde sua 
evolução histórica até a estrutura e tipos, com foco na utilização do Linux. 
Componentes e Papel do SO: 
• Um sistema computacional é composto por usuários, hardware e software. 
O software inclui aplicativos e sistemas operacionais. 
• O sistema operacional atua como uma interface entre os aplicativos e o 
hardware, simplificando o uso para usuários e desenvolvedores, e garantindo 
o uso eficiente do hatrdware. 
• Ele controla e coordena o uso do hardware entre diversos programas e 
usuários. 
• O SO é um programa de controle que coordena a execução de programas 
do usuário e operações de E/S, além de ser um gerenciador de recursos de 
hardware. 
• Apresenta uma visão abstraída do hardware e de rotinas de software, o 
que é fundamental para profissionais de computação. Essa abstração pode ser 
representada por um modelo de máquina de níveis ou camadas. 
Modos de Acesso e Estrutura do SO: 
• Programas podem ser executados em modo usuário (acesso limitado ao 
hardware) ou modo kernel (ou núcleo). 
• O SO é o único programa executado em modo kernel, tendo acesso 
completo e irrestrito ao hardware e executando qualquer instrução possível. 
• O kernel é o conjunto de rotinas do sistema operacional que oferece serviços 
e atua no tratamento de interrupções e exceções, criação e eliminação de 
processos e threads, gerência de memória, sistema de arquivos, dispositivos de 
E/S, suporte a redes, contabilização e segurança. 
• As system calls (chamadas ao sistema) são um mecanismo de proteção por 
software que permite a comunicação entre programas de aplicação e o kernel, 
garantindo que as rotinas do SO sejam executadas apenas se a aplicação 
possuir os privilégios necessários. Exemplos 
incluem fork(), read(), write(), CreateProcess e ReadFile. Padrões 
como POSIX (para sistemas Unix-like) e Win32 API (para Windows) 
definem esses conjuntos de chamadas. 
Evolução Histórica e Tipos de SO: 
• A evolução dos SO está ligada à arquitetura dos computadores, dividida em 
gerações. 
 ◦ Primeira Geração (1945-1955): Programação em painéis físicos, uso de 
válvulas. 
 ◦ Segunda Geração (1955-1965): Adoção de transistores, sistemas de 
computação em lote (batch). 
 ◦ Terceira Geração (1965-1980): Estabelecimento do conceito de SO, 
inovações como multiprocessamento, multiprogramação, time-sharing, 
spooling e memória virtual. Surgimento do UNIX e circuitos integrados. 
 ◦ Quarta Geração (1980-atual): Computadores pessoais, integração em 
larga escala (LSI, VLSI, ULSI), microprocessadores (Intel 4004, 8080), 
surgimento da Microsoft, redes distribuídas, protocolos TCP/IP, estações de 
trabalho, interfaces gráficas, software aberto, processamento distribuído, SO 
em celulares e tablets. 
• SO Windows: Começou com MS-DOS (1981, 16 bits, monoprogramável, 
monousuário, linha de comando). Evoluiu para MS Windows 1.0 (1985, 
interface gráfica), Windows NT (1993, 32 bits, multitarefa preemptiva, 
multithread, memória virtual, novo núcleo), e versões posteriores (Windows 
2000, XP, Vista, 7, 8, 10, Windows Server). 
• SO Unix: Desenvolvido em 1969 por Ken Thompson (Bell Labs) como 
UNICS, reescrito em C em 1973 para portabilidade. Influenciou o 
desenvolvimento de variantes como BSD e Linux. O POSIX buscou 
padronizar suas chamadas. 
• Classificação dos SO: 
 ◦ Monoprogramáveis/Monotarefa: Recursos alocados a um único 
programa por vez, o processador permanece ocioso durante operações de E/S. 
 ◦ Multiprogramáveis/Multitarefa: Recursos compartilhados, vários 
programas/processos utilizam o processador de forma concorrente, 
aproveitando o tempo de ociosidade de E/S. O grau de multiprogramação 
afeta a utilização da CPU. 
 ◦ Com Múltiplos Processadores: Dois ou mais processadores atuando 
juntos para escalabilidade, disponibilidade e balanceamento de carga. Podem 
ser fortemente acoplados (compartilham memória principal, único SO – 
SMP, NUMA) ou fracamente acoplados (sistemas independentes conectados 
por comunicação). 
 ◦ Sistemas em Lote (Batch): Processam tarefas de rotina sem interação do 
usuário. 
 ◦ Sistemas de Processamento de Transações: Administram grandes 
volumes de pequenas requisições rapidamente. 
 ◦ Sistemas de Tempo Compartilhado: Permitem que múltiplos usuários 
remotos executem tarefas simultaneamente. 
 ◦ Sistemas de Tempo Real: Têm o tempo como parâmetro fundamental. 
Podem ser críticos (ações precisam ocorrer em instantes específicos, como 
processos industriais, aviônicos, militares) ou não críticos (descumprimento 
de prazo não causa dano permanente, como áudio digital, multimídia). 
• Licenciamento de Software: 
 ◦ Software Proprietário: Licenciado sob direitos autorais exclusivos, 
código-fonte não disponível para modificação. 
 ◦ Software Livre (Free Software): Foco na liberdade de executar, copiar, 
distribuir, estudar, modificar e aperfeiçoar o software, com acesso ao código-
fonte (ex: licença GNU). 
 ◦ Software de Código Aberto (Open Source): Código-fonte disponível 
para modificação, mas não necessariamente respeita as 4 liberdades da FSF 
(ex: Apache, MIT License). 
Arquiteturas de Kernel: 
• Monolítica (Mono-kernel): Todos os módulos do SO compilados e ligados 
em um único executável, interagindo livremente. Não há ocultação de 
informação. 
• De Camadas: Sistema dividido em camadas hierárquicas, cada uma 
oferecendo funções para a camada superior. Vantagens: isolamento, 
manutenção, depuração; Desvantagens: desempenho comprometido. 
• Máquina Virtual (VM): Cria um nível intermediário (gerenciador de 
máquinas virtuais ou hypervisor) entre hardware e SO, permitindo múltiplas 
máquinas virtuais independentes, cada uma com uma cópia virtual do 
hardware (virtualização). 
• Microkernel: Núcleo pequeno e simples, contendo apenas serviços 
essenciais (gerência de arquivos, processos, memória, escalonamento). Outros 
módulos executam como processos de usuário. Alta confiabilidade e 
segurança. 
• Exokernel: Fornece um subconjunto de recursos de hardware para cada 
usuário (máquina virtual), alocando recursos e verificando tentativas de uso 
para garantir que uma máquina não acesse recursos de outra. 
Linux – Exemplo Prático: 
• O Linux é um sistema operacional "Unix-like", multitarefa e multiusuário, 
gratuito e de código aberto, com diversas distribuições (ex: Ubuntu). 
• Sua estrutura de diretórios é hierárquica, partindo de uma única raiz (/). 
Exemplos: /home (pasta pessoal), /bin (executáveis binários), /etc (arquivos 
de configuração), /var (arquivos variáveis). 
• O superusuário no Linux é o root, com poderes administrativos especiais. 
• Comandos básicos de terminal são essenciais, 
como ls, cd, pwd, mkdir, rmdir, rm, cp, mv, cat, find, ln. 
-------------------------------------------------------------------------------- 
 
Tema 3 - Processos e Gerência de 
Processador 
 
Este tema aprofunda os conceitos de processos, threads e a forma como são 
gerenciados para a construção de sistemas eficientes, explorando o 
aproveitamento da capacidade de multiprocessamento dos equipamentos 
atuais. 
Conceitos de Processos: 
• Nos sistemas multiprogramáveis, o software é organizado em processos 
sequenciais. 
• Um processo é um programa em execução, incluindo o estado dos 
registradores, variáveis e o espaço de endereçamento. Cada processo tem seu 
próprio Contador de Instruções. 
• Em um sistema multiprogramável, a UCP alterna entre processos 
(pseudoparalelismo), dando a ilusão de execução simultânea. 
• Processos são criados pela inicialização do sistema, chamadas de sistema 
(ex: fork()), solicitação do usuário ou início de tarefas em lote. 
• Um Process ID (PID) identifica unicamente um processo. 
• Processos podem terminar por saída normal, saída por erro, erro fatal ou 
serem mortospor outro processo. 
• No Linux, um processo especial chamado systemd (ou init) é o primeiro a 
ser executado e é a raiz de uma hierarquia de processos. 
Estados e Contexto de Processos: 
• Um processo transita pelos estados: novo, pronto, executando, bloqueado 
e terminado. 
 ◦ Novo: Processo criado, aguardando SO tomar providências. 
 ◦ Pronto: Processo reúne condições para ser executado, aguardando UCP. 
 ◦ Executando: UCP executa instruções do processo. 
 ◦ Bloqueado: Aguardando conclusão de operação de E/S ou outro evento. 
 ◦ Terminado: Não será mais executado, SO desaloca recursos. 
• O Bloco de Controle de Processo (BCP ou PCB) contém todas as 
informações do processo (estado, prioridade, PID, registradores, gerência de 
memória, E/S, contabilidade). 
• O escalonador (scheduler) gerencia interrupções, inicia/para processos e 
seleciona o próximo processo a ser executado. 
• Mudança de contexto é a tarefa de guardar o estado de um processo em 
execução e carregar o estado do próximo processo. O contexto inclui: 
 ◦ Contexto de hardware: Conteúdo dos registradores. 
 ◦ Contexto de software: Identificação (PID, UID, GID), quotas e 
privilégios. 
 ◦ Espaço de endereçamento: Área de memória para o programa e dados. 
Subprocessos e Threads: 
• Subprocessos (ou processos filhos) permitem dividir uma aplicação em 
partes concorrentes, aproveitando o multiprocessamento. No Linux, a 
chamada fork() cria um processo idêntico ao pai, com seu próprio espaço de 
endereçamento. A chamada execve() substitui a imagem de execução de um 
processo. 
• Threads são linhas de execução concorrentes dentro de um processo. 
 ◦ Compartilham o mesmo espaço de endereçamento e recursos do processo 
(arquivos abertos, processos filhos, alarmes), mas cada thread tem seu próprio 
conjunto de registradores e pilha. 
 ◦ A mudança de contexto entre threads é mais leve/rápida que entre 
processos. 
 ◦ São conhecidos como processos leves e trabalham cooperativamente. 
 ◦ Podem ser gerenciados no espaço do usuário (mais rápido, mas um 
bloqueio afeta todo o processo) ou pelo núcleo (chaveamento mais lento, mas 
um bloqueio não suspende todo o processo). 
 ◦ No Linux, threads são criados com a chamada clone(), que permite 
definir quais recursos serão compartilhados via flags. 
 ◦ O Linux não faz distinção entre processos e threads, tratando-os 
como tarefas (tasks), mas associa PIDs diferentes a cada tarefa (mesmo 
threads do mesmo processo). O mecanismo copy on write é usado para 
compartilhar segmentos de memória entre pai e filho, copiando apenas quando 
uma escrita ocorre. 
• Tipos de Processos: 
 ◦ CPU-bound: Passam a maior parte do tempo executando, realizando 
poucas operações de E/S (ex: aplicações científicas). 
 ◦ I/O-bound: Passam a maior parte do tempo bloqueados, realizando 
muitas operações de E/S (ex: aplicações comerciais, interativas). 
Comunicação e Sincronização entre Processos: 
• Condição de corrida: Ocorre quando múltiplos processos acessam e 
modificam dados compartilhados e o resultado depende da ordem de 
execução, levando a inconsistências. 
• Região crítica: Seção de código onde processos acessam recursos 
compartilhados. A exclusão mútua é necessária para evitar condições de 
corrida. 
• Mecanismos de Sincronização: 
 ◦ Semáforos: Variáveis inteiras que contam sinais e usam operações 
atômicas up (incrementa e libera) e down (decrementa ou bloqueia) para 
controlar o acesso à região crítica. 
 ◦ Monitores: Mecanismos de alto nível (implementados por linguagens de 
programação, não pelo SO diretamente no Linux) que agrupam variáveis, 
procedimentos e estruturas de dados, garantindo que apenas um processo 
esteja ativo no monitor por vez. 
• Comunicação no Linux: 
 ◦ Semáforos: Suportados via sem_wait(), sem_post() e sem_trywait(). 
 ◦ Pipes (|): Conectam a saída padrão de um processo à entrada padrão de 
outro, permitindo execução concorrente e troca de mensagens. 
 ◦ Sinais: Enviados na ocorrência de eventos (rede, temporizador, término 
de filho) para serem tratados por rotinas específicas ou pelo kernel. 
Exemplos: SIGHUP, SIGINT, SIGKILL, SIGCHLD. 
Escalonamento: 
• Escalonamento (scheduling) é o procedimento de seleção de processos para 
alocação da UCP. 
• Pode ser preemptivo (o sistema pode interromper um processo em 
execução) ou não preemptivo (o processo só libera a UCP voluntariamente). 
• Algoritmos de Escalonamento: 
 ◦ First In First Out (FIFO): O primeiro a chegar é o primeiro a ser 
executado, não preemptivo, fácil de implementar, mas imprevisível para 
tempo de resposta. 
 ◦ Shortest Job First (SJF): Associa a cada processo seu tempo de 
execução e escolhe o mais curto. Não preemptivo, reduz tempo médio de 
espera, mas exige conhecimento prévio do tempo de execução. 
 ◦ Shortest Remaining Time Next (SRTN): Versão preemptiva do SJF, 
escolhe o processo com menor tempo restante de execução. 
 ◦ Cooperativo: Processo em execução libera voluntariamente a UCP. Não 
preemptivo, mas pode levar à monopolização da UCP por programas mal 
escritos. 
 ◦ Circular (Round Robin): Trata a fila de processos como circular, 
alocando a UCP para cada processo por um quantum (intervalo de tempo). 
Preemptivo, garante que nenhum processo monopolize a UCP. 
 ◦ Por Prioridade: Processos com maior prioridade são escalonados 
preferencialmente. Preemptivo, pode ter prioridade estática ou dinâmica. 
 ◦ Por Múltiplas Filas: Classifica processos em grupos (ex: sistema, 
interativo, batch) e aplica mecanismos de escalonamento distintos a cada fila, 
com prioridades entre as filas. 
 ◦ Em Sistemas de Tempo Real: Essencial onde o tempo é crítico. Existem 
sistemas de tempo real crítico (prazos absolutos) e não crítico (prazos 
toleráveis). Algoritmos podem ser estáticos ou dinâmicos. 
 ◦ De Threads: Pode ser gerenciado pelo núcleo (preemptivo, mais caro) ou 
pelo usuário (cooperativo, mais rápido, mas um bloqueio afeta o processo). 
• Escalonamento no Linux: Suporta multitarefa preemptiva e usa um 
algoritmo de escalonamento por múltiplas filas com três classes de tarefas: 
FIFO em tempo real (maior prioridade), escalonamento circular em tempo 
real, e tempo compartilhado (menor prioridade). O utilitário nice permite 
alterar a prioridade de tarefas de tempo compartilhado. 
-------------------------------------------------------------------------------- 
 
Tema 4 – Memória 
 
Este tema explora a organização e o funcionamento da memória de um 
computador, o gerenciamento pelo sistema operacional, a utilização da 
memória virtual e sua implementação no Linux. 
Elementos e Gerência de Memória: 
• A memória é um recurso crucial do computador, com diferentes níveis de 
armazenamento com características variadas de custo, velocidade e 
capacidade. 
 ◦ Armazenamento Interno: Registradores e cache (memória de trabalho 
do processador, volátil). 
 ◦ Armazenamento Primário (RAM): Memória principal, armazena 
código e dados de programas, acessível diretamente pelo processador (volátil). 
 ◦ Armazenamento Secundário (Massa): Discos de estado sólido, 
magnéticos, ópticos, fitas magnéticas (não volátil, para uso posterior). 
• As funções do SO na gerência de memória incluem: controlar espaços 
disponíveis, impedir acesso indevido entre processos e transferir dados entre 
memória primária e secundária. 
Visão da Memória pelos Processos: 
• A memória física é o conjunto real de bytes acessíveis individualmente pelo 
hardware, com endereçamento físico. 
• Os processos veem a memória como um conjunto de endereços lógicos, que 
compõem o espaço de endereçamento do processo. 
• Em sistemas modernos, o espaço de endereçamento lógico (ou memória 
virtual) é frequentemente maior que a memória física disponível. 
• O modelo de memória de um processo 
inclui: Text (código), Data (variáveis), Heap (variáveistemporárias/dinâmicas) e Pilha (registros de ativação, variáveis locais). 
• É necessária uma tradução de endereço lógico para físico. 
Proteção e Relocação de Memória: 
• A proteção de memória garante que cada processo tenha um espaço de 
memória separado, impedindo que um invada a área de outro. 
• É implementada usando registradores base e limite. O registrador base 
define o limite inferior e a soma do limite com o base define o limite superior. 
• A MMU (Memory Management Unit) verifica se um endereço está dentro 
do intervalo legal do processo; caso contrário, gera um erro fatal. 
• O SO, em modo kernel, tem acesso total à memória. 
• Relocação permite que um processo seja carregado em diferentes posições 
da memória física. 
 ◦ Estática: Mapeamento de endereços feito antes do carregamento do 
módulo. 
 ◦ Dinâmica: Toda referência é lógica e mapeada pelo hardware durante a 
execução, usando um registrador de relocação. 
Políticas de Alocação de Memória: 
• Podem manter processos na memória principal ou movê-los entre principal e 
secundária (swapping ou paginação). 
• Gerenciamento sem permuta: 
 ◦ Alocação Contígua: Memória compartilhada entre SO e um processo de 
usuário. Desvantagem: limita o tamanho do programa. 
 ◦ Overlay: A mesma região de memória é ocupada por módulos diferentes 
de um processo que excede a memória disponível, o programador divide o 
código em módulos principal e secundários. Primeiro uso de permuta. 
 ◦ Alocação Particionada Fixa: Memória dividida em partições fixas, cada 
uma aloca um processo. Gera desperdício de memória (fragmentação interna). 
 ◦ Alocação com Partições Variáveis: Memória dividida dinamicamente. 
Problemas: fragmentação externa (pequenos pedaços livres não contíguos). 
 ◦ Políticas de Escolha de Partição: 
 ▪ Best-Fit: Aloca na partição disponível de tamanho mais próximo 
(menores fragmentos livres). 
 ▪ First-Fit: Aloca na primeira partição onde o processo couber (mais 
rápido). 
 ▪ Worst-Fit: Aloca na maior partição disponível (intuitivamente, sempre 
caberá um processo pequeno no espaço resultante). 
• Gerenciamento com permuta (Swapping): Move processos da memória 
principal para a secundária (disco) e vice-versa, aumentando o grau de 
multiprogramação. Usa relocação dinâmica. É lento devido ao tempo de E/S, 
por isso não é usado em sistemas modernos, sendo substituído por paginação. 
• Gerenciamento de Espaço Livre: 
 ◦ Mapas de Bits: Memória dividida em unidades de alocação, cada uma 
com um bit (0 livre, 1 ocupada). Lento para encontrar sequências de blocos 
livres. 
 ◦ Listas Encadeadas: Cada nó representa um segmento alocado ou livre. 
Memória Virtual e Paginação: 
• Memória Virtual: Permite que o espaço de endereçamento lógico de um 
programa seja muito maior que a memória física. Somente partes do programa 
são carregadas na memória principal conforme necessário. 
• Paginação: Divide o espaço de endereços lógico em páginas de igual 
tamanho e a memória principal em molduras (frames) de igual tamanho. 
 ◦ A tabela de páginas mapeia páginas virtuais para molduras físicas. 
 ◦ Controle de Espaço Livre: SO mantém uma lista de molduras livres. 
 ◦ Proteção de Memória: Bits de proteção na tabela de páginas 
(leitura/escrita, válido/inválido). 
 ◦ Paginação sob Demanda: Carrega páginas na memória somente quando 
referenciadas. Se uma página não estiver presente, ocorre uma page fault 
(falta de página), e o SO carrega a página do disco. 
 ◦ Working Set: Conjunto de páginas mais acessadas por um processo, 
mantidas na memória para minimizar page faults. 
 ◦ Políticas de Liberação de Páginas (Substituição): Escolhem qual página 
remover da memória quando não há molduras livres. Exemplos: 
 ▪ Página Aleatória. 
 ▪ First-In-First-Out (FIFO): Remove a página carregada há mais 
tempo. 
 ▪ Least-Recently-Used (LRU): Remove a página usada pela última vez 
há mais tempo (alto overhead). 
 ▪ Not-Recently-Used (NRU): Substitui páginas não utilizadas nos 
últimos K acessos. 
 ▪ Least-Frequently-Used (LFU): Escolhe a página com menor número 
de acessos (alto overhead). 
 ▪ Algoritmo de Segunda Chance (Clock): Variação do FIFO que usa 
um bit de referência. Se o bit for 0, substitui; se for 1, zera o bit e dá uma 
"segunda chance", passando para a próxima página. Pode ser aprimorado com 
o bit de modificação. 
• Segmentação: Divide o programa em segmentos de comprimentos variados 
com sentido lógico (divisão lógica), em contraste com a divisão física da 
paginação. Usa uma tabela de segmentos para mapeamento de endereços. 
Gerenciamento de Memória no Linux: 
• Envolve a alocação/liberação da memória física e a manipulação da memória 
virtual. 
• Memória Física: Dividida em zonas (ex: Intel x86 de 32 
bits: ZONE_DMA, ZONE_NORMAL, ZONE_HIGHMEM). Em 64 bits, apenas ZONE_DMA (para 
dispositivos legados) e ZONE_NORMAL. 
• Memória Virtual: O Linux mantém uma visão lógica (regiões não 
sobrepostas) e uma visão física (entradas nas tabelas de páginas de hardware). 
 ◦ A criação de novos processos via exec() gera um espaço de 
endereçamento virtual vazio. Via fork(), o filho copia o espaço de 
endereçamento virtual do pai, e ambos compartilham páginas físicas (copy-
on-write). 
 ◦ A substituição de páginas no Linux usa uma política similar ao algoritmo 
do relógio, com múltiplos ciclos e um conceito de "idade" para páginas 
(política LFU). 
 ◦ O kernel reserva uma região constante da memória virtual para uso 
interno, inacessível a programas de usuário. 
• Carga de Programas: O carregador binário do Linux mapeia páginas do 
arquivo binário para regiões de memória virtual usando paginação sob 
demanda. Formato ELF. 
• Vinculação Estática e Dinâmica: 
 ◦ Estática: O código da biblioteca é embutido no executável. Desvantagem: 
duplicação de funções comuns. 
 ◦ Dinâmica: Bibliotecas são carregadas na memória uma única vez e 
compartilhadas por programas. 
• Utilitários para Gerenciar Memória no Linux: free (uso de RAM e 
swap), top (informações de processos e memória), vmstat (situação da 
memória virtual), getconf PAGESIZE (tamanho da página), swapon (arquivo de 
swap), htop (interativo, evolução do top), ksysguard (interface gráfica), 
Monitor do Sistema (padrão do GNOME). 
-------------------------------------------------------------------------------- 
 
Tema 5 - Sistema de Arquivos 
 
Este tema aborda as tecnologias de particionamento e formatação de sistemas 
de arquivos, sua implementação e gerenciamento no Linux. 
Conceitos Fundamentais: 
• Os sistemas de arquivos são responsáveis por garantir a persistência das 
informações, armazenando-as em dispositivos intermediários como discos. 
• As principais exigências para armazenamento incluem: grande quantidade de 
informações, persistência (sobreviver à finalização do processo) e acesso 
concorrente por múltiplos processos. 
• Um sistema de arquivos é composto por: conjunto de arquivos (armazena 
dados) e estrutura de diretórios (organiza e fornece informações sobre 
arquivos). 
• Um arquivo é uma unidade lógica de informação, identificada por um nome 
(com ou sem extensão, dependendo do SO). A extensão pode ser apenas uma 
convenção ou ter significado para o compilador. 
Estrutura e Métodos de Acesso a Arquivos: 
• Estruturas de Arquivos: 
 ◦ Sequência Desestruturada de Bytes: Mais simples, o sistema de 
arquivos não impõe estrutura (Linux e MS Windows usam essa abordagem). 
 ◦ Sequência de Registros de Tamanho Fixo: Arquivo composto por 
registros com estrutura interna. 
 ◦ Árvore de Registros: Registros de tamanhos variados, ordenados por um 
campo chave para busca rápida. 
• Métodos de Acesso: 
 ◦ Acesso Sequencial: Registros acessados na ordem em que foram 
gravados, novos registros apenas no final. 
 ◦ Acesso Aleatório (Direto):Permite leitura/gravação de um registro 
diretamente em sua posição relativa. Todos os arquivos em SO modernos são 
de acesso aleatório, a menos que o dispositivo não permita. 
 ◦ Acesso Indexado: Usa um índice para encontrar registros. 
• Tipos de Arquivos: 
 ◦ Arquivos Regulares: Informações genéricas (dados de usuários, texto ou 
binário). 
 ◦ Diretórios: Arquivos de sistema para manter a estrutura do sistema. 
 ◦ Arquivos Especiais de Caractere e Bloco: Modelam dispositivos de E/S. 
Diretórios e Hierarquia: 
• Um diretório (pasta) é um arquivo que contém uma estrutura de dados com 
entradas associadas a outros arquivos/diretórios. 
• Estruturas de Diretórios: 
 ◦ Nível Único: Um único diretório para todos os arquivos (obsoleto). 
 ◦ Dois Níveis: Um diretório para arquivos do sistema e um para cada 
usuário, com um master file directory. 
 ◦ Estrutura em Árvore (Hierárquica): Permite múltiplos diretórios e 
subdiretórios, com um caminho (path) único para cada arquivo desde a raiz 
(/). Adotado pela maioria dos SO modernos. 
 ▪ Caminho Absoluto: Da raiz até o arquivo. 
 ▪ Caminho Relativo: A partir do diretório de trabalho (atual). 
• Entradas especiais nos diretórios: . (diretório atual) e .. (diretório pai). 
Implementação do Sistema de Arquivos em Disco: 
• Discos são o meio de armazenamento secundário mais comum, com 
transferências em setores. 
• Discos podem ser divididos em partições, cada uma com sistemas de 
arquivos independentes. 
• MBR (Master Boot Record) no Setor 0 do disco, usado para inicializar o 
computador e contém a tabela de partição. Cada partição começa com um 
bloco de inicialização. 
• Uma partição geralmente contém: superbloco (parâmetros chave do sistema 
de arquivos), mapas de bits ou lista encadeada (controle de blocos livres), i-
nodes (estrutura de dados por arquivo, com informações e dados dos blocos), 
diretório-raiz e demais diretórios/arquivos. 
• Alocação Contígua: Arquivos armazenados em blocos contíguos. 
Vantagens: simples de implementar, excelente desempenho de leitura. 
Desvantagem: exige cadeia de blocos contíguos livres, leva à fragmentação 
do disco (necessidade de desfragmentação). Usado em CD-ROMs. 
• Alocação por Lista Encadeada: Arquivo organizado como conjunto de 
blocos logicamente ligados, independente da localização física. Não ocorre 
fragmentação do disco, mas sim fragmentação de arquivos (quebra do 
arquivo em blocos espalhados) e desperdício de espaço com ponteiros. 
Permite apenas acesso sequencial. Problema de confiabilidade se um ponteiro 
é corrompido. 
• Alocação por Lista Encadeada Utilizando Índice (FAT): A cadeia de 
blocos é mantida em uma tabela na memória principal (FAT). Acesso mais 
rápido, mas a tabela pode ser muito grande para discos grandes. Pode agrupar 
blocos em clusters para formar unidades maiores. 
• Alocação por I-node: Cada arquivo possui um i-node que lista atributos e 
endereços em disco dos blocos. Os primeiros endereços de disco são no 
próprio i-node, para arquivos maiores usa blocos indiretos simples, duplos e 
triplos. O i-node precisa estar na memória apenas quando o arquivo está 
aberto. 
• Implementação de Cache: Reserva uma área na memória principal para 
blocos de disco acessados frequentemente, melhorando o desempenho de E/S. 
 ◦ Cache Write-through: Atualiza o disco imediatamente a cada 
modificação do bloco na cache. 
 ◦ Cache Write-back: Atualiza o disco periodicamente, com risco de perda 
de dados em caso de falha de energia, mas menor quantidade de operações de 
E/S. 
O Sistema de Arquivos do Linux: 
• O Linux trata qualquer objeto capaz de manipular dados como um arquivo, 
usando uma camada de software chamada VFS (Virtual File System) para 
ocultar detalhes específicos de implementação. 
• O VFS define objetos principais: i-node (representa arquivo 
individual), arquivo (arquivo aberto), superbloco (sistema de arquivos 
inteiro) e dentry (entrada de diretório). 
• Suporta dezenas de sistemas de arquivos diferentes devido ao VFS. 
O ext2 resolveu problemas de desempenho do ext e se tornou o principal 
sistema de arquivos do Linux. O ext3 introduziu o journaling. 
• Journaling: Alterações são gravadas sequencialmente em um diário (log) 
antes de serem escritas nos blocos de disco. Melhora o desempenho da 
gravação e a recuperação do sistema após uma falha. 
• O Linux não exige extensões de arquivo nem limita o tipo ou quantidade de 
caracteres em extensões. 
• O diretório raiz é /. 
• Principais diretórios no 
Linux: /bin, /boot, /dev, /home, /etc, /lib, /media, /mnt, /opt, /proc, /root, /
sbin, /srv, /sys, /tmp, /usr, /var. 
Gerenciamento de Discos e Partições no Linux: 
• Dispositivos são identificados por arquivos especiais 
em /dev (ex: /dev/sda, /dev/sdb1). 
• Formatação: Processo de criar a estrutura do sistema de arquivos dentro de 
uma partição (grupos de blocos, superbloco, descritor de grupo, mapas de bits, 
i-nodes, blocos de dados). 
• Montagem: Um sistema de arquivos de um dispositivo/partição é montado 
sobre a árvore de diretórios do sistema. 
• Comandos de Gerenciamento: 
 ◦ fsck: Verifica e corrige um sistema de arquivos. 
 ◦ df: Exibe espaço livre/ocupado por sistemas de arquivos montados. 
 ◦ lsblk: Lista informações sobre dispositivos de bloco. 
 ◦ /etc/fstab: Arquivo com informações sobre sistemas de arquivos a serem 
montados. 
• Arquivos Ocultos: No Linux, arquivos que começam com . (ponto) são 
ocultos. 
• Links Simbólicos (Soft Links): Entradas de diretório que apontam para 
outras entradas de diretórios (atalhos). Criados com ln -s. 
• Hardlinks (Links Duros): Diferentes entradas de diretórios que apontam 
para o mesmo i-node (o mesmo arquivo). Criados com ln (sem -s). O sistema 
de arquivos mantém uma contagem de hardlinks. 
Editores de Arquivos no Linux: 
• Arquivos de texto puro (ASCII) são comuns para configuração do sistema, 
diferente de documentos de processadores de texto. 
• Vim (Vi Improved): Editor modal (modos de comando e edição), pequeno e 
leve, disponível em toda distribuição Linux. Usado para manutenção de 
emergência ou no dia a dia. Possui diversos comandos para inserção, 
movimentação, exclusão, cópia, busca e salvamento. 
• Nano: Editor de texto para linha de comando mais simples, com comandos 
visíveis na parte inferior da tela. 
• Gedit: Editor de textos puro em modo gráfico, padrão do ambiente GNOME 
(ex: Ubuntu Desktop). Auxilia na edição com tabulações e coloração de 
palavras reservadas. 
-------------------------------------------------------------------------------- 
 
Tema 6 - Automatizando Tarefas no 
Linux 
 
Este tema aborda ferramentas para automatização de tarefas em sistemas 
Linux, utilizando a ferramenta CRON e programação SHELL SCRIPT. 
CRON para Agendamento de Tarefas: 
• CRON: Ferramenta criada no UNIX para automatizar a execução de 
processos em dias e horários específicos, sem intervenção do usuário. 
• É uma ferramenta multiusuário, ou seja, cada usuário tem sua própria 
configuração (CRONTAB), e os processos são executados pelo usuário dono da 
configuração. 
• CRONTAB: A configuração de agendamento de um usuário. Editada com o 
comando crontab -e. 
• Formato do CRONTAB: Cada linha representa uma tarefa e contém 6 ou 
mais campos separados por espaços: 
 1. Minuto (0-59) 
 2. Hora (0-23) 
 3. Dia do Mês (1-31) 
 4. Mês (1-12 ou abreviação em inglês) 
 5. Dia da Semana (0-7, 0 ou 7 para domingo) 
 6. Comando a ser executado. 
• Máscaras: O caractere * representa "qualquer valor". Podem ser usados 
valores separados por vírgula (ex: 0,15,30,45 para minutos) ou intervalos 
(ex: 8-17 para horas). O caractere / define o período entre intervalos (ex: */2 a 
cada 2). 
• Exemplo: 0 20 * * * tar -cfz /tmp/backup.tar.gz /home/bob executa um 
backup às 20h todos os dias. 
• Importante: Não usar sudo dentro do CRONTAB deusuário, pois exige 
digitação de senha e não é interativo. Para tarefas do root, configure 
diretamente no CRONTAB do root. 
• Configuração Global do CRON (/etc/crontab): Usada para rotinas de 
serviços e processos do sistema. Inclui um campo adicional para o usuário que 
executará o comando (ex: 30 10 * * * root /bin/comando). Possui diretórios 
para rotinas horárias, diárias, semanais e mensais 
(ex: /etc/cron.hourly, /etc/cron.daily). 
SHELL SCRIPTS para Automatização: 
• SCRIPTS: Arquivos-texto com sequências de comandos a serem 
executados pelo SHELL. 
• São lidos e interpretados diretamente pelo SHELL, não necessitam de 
compilação. 
• Permitem desenvolver lógicas avançadas com variáveis de ambiente, 
comandos de comparação e estruturas de repetição para automatizar tarefas 
complexas. 
• Interpretador de Shell: O BASH é o padrão na maioria das distribuições 
Linux. 
• Palavra Mágica (#!): Todo SCRIPT deve iniciar 
com #!/caminho/para/interpretador, indicando que é um SCRIPT e qual 
interpretador usar (ex: #!/bin/bash). 
• Permissão de Execução: É necessário conceder permissão de execução ao 
arquivo (chmod u+x script1). 
• Execução: Para executar um SCRIPT no diretório atual, use ./script1. 
• Comentários: Linhas iniciadas com # (exceto a palavra mágica) são 
ignoradas e usadas para comentários. 
• Comando echo: Exibe texto na saída padrão (stdout). 
 ◦ -n: Inibe a quebra de linha. 
 ◦ $(comando): Executa um comando e insere seu resultado no texto. 
 ◦ -e: Permite o uso de caracteres especiais como \n (quebra de linha). 
• Comando sleep: Cria pausas na execução do SCRIPT por um tempo 
configurável em segundos. 
• Comando read: Aguarda interação do usuário, recebendo um valor e 
atribuindo-o a uma variável. Pode ser usado com -s para não exibir a entrada. 
• Comando clear: Apaga todo o conteúdo do terminal. 
• Valor de Retorno (exit): Processos retornam um valor numérico ao SO (0 
para sucesso, 1-255 para erros). exit N termina o SCRIPT com o valor N. 
Variáveis de Ambiente e Estruturas de Decisão: 
• Variáveis: Armazenam informações com nome e valor. 
 ◦ Atribuição: VAR=valor (sem espaços no =). Use aspas para textos com 
espaços (ex: VAR="Terminal do Linux"). 
 ◦ Referência: Use $ antes do nome da variável (ex: $VAR). 
 ◦ Sem tipo: O BASH não tipa variáveis; a interpretação depende do 
contexto. 
 ◦ Atribuição da saída de um comando: VAR=$(comando). 
• Parâmetros de SCRIPT: Passados na execução, acessados pelas 
variáveis $1, $2, .... $0 é o nome do próprio SCRIPT. Para parâmetros 
acima de 9, use ${10}. 
• Estrutura if (Decisão): Avalia uma condição e executa blocos de código 
condicionalmente. 
 ◦ Sintaxe: if [ CONDIÇÃO ]; then # Tarefas; else # Tarefas; fi. 
 ◦ Comparadores Numéricos: 
 ▪ -eq: Igual a. 
 ▪ -ne: Diferente de. 
 ▪ -gt: Maior que. 
 ▪ -ge: Maior ou igual a. 
 ▪ -lt: Menor que. 
 ▪ -le: Menor ou igual a. 
 ◦ Comparadores de Cadeias de Caracteres (Strings): 
 ▪ =: Igual a. 
 ▪ !=: Diferente de. 
 ▪ -z: Cadeia nula/vazia. 
 ▪ -n: Cadeia não nula. 
• Operações Aritméticas: 
 ◦ (( C=A+B )) ou $( (A+B) ). 
 ◦ Incremento: (( X++ )). 
 ◦ Ponto Flutuante: O BASH não faz nativamente; use o 
comando bc (ex: echo "scale=2; (A+B+C)/3" | bc). 
Estruturas de Repetição (Loops): 
• Estrutura while: Repete um bloco de comandos enquanto uma condição 
for verdadeira. 
 ◦ Sintaxe: while [ CONDIÇÃO ]; do comando1; comando2; ...; done. 
• Comandos break e continue: 
 ◦ break: Interrompe imediatamente o LOOP. 
 ◦ continue: Força uma nova iteração do LOOP, ignorando comandos 
restantes no bloco atual. 
• Estrutura for: Realiza um LOOP a partir de uma lista de variáveis. 
 ◦ Sintaxe: for variavel in lista; do comando; done. 
 ◦ Pode usar máscaras de arquivos (ex: for arquivo in * para listar todos os 
arquivos/diretórios no atual). 
• Obtenção de Variável a partir de Arquivo: Use redirecionador de entrada 
(ex: DIRETORIOS=$(>) ou configurar o CRON para 
enviar saídas por e-mail local. 
• Expressões Regulares (regex): Podem ser usadas com o 
comparador =~ para validações complexas de strings (ex: if [[ $numero =~ 
^{3}$ ]]). 
--------------------------------------------------------------------------------