Sistema Operacional SO

www.cliqueapostilas.com.
br
SISTEMA
OPERACIONAL
Prof: Fernando
www.cliqueapostilas.com.br
Sumário
APOSTILA E EXERCICIOS DA DISCIPLINA SISTEMA OPERACIONAL ..................... 4
1. Introdução ...................................................................................................................... 4
1.1 Facilidade de acesso aos recursos do sistema ............................................................ 5
1.2 Compartilhamento de recursos de forma organizada e protegida .............................. 6
2. Um breve histórico dos Sistemas Operacionais ............................................................. 7
3. Tipos de Sistemas Operacionais .................................................................................. 12
3.1 Classificação ............................................................................................................. 12
3.1.1 Sistema monoprogramável/ monotarefa ............................................................. 13
3.1.2 Sistema multiprogramável/ multitarefas ............................................................. 13
3.1.3 Sistemas com múltiplos processadores .............................................................. 18
3.2 Alguns Tipos de Sistemas Operacionais .................................................................. 20
4. Estrutura de Sistemas Operacionais ............................................................................. 22
4.1 Estrutura ................................................................................................................... 24
4.2 Funcionalidades ........................................................................................................ 25
4.3 Proteção do núcleo ................................................................................................... 27
4.4 Interrupções e Chamadas de Sistemas...................................................................... 28
4.5 Sistemas monolíticos ................................................................................................ 31
4.6 Sistemas em Camadas .............................................................................................. 32
4.7 Sistemas Micronúcleo (Cliente-Servidor) ................................................................ 33
4.8 Máquinas Virtuais .................................................................................................... 34
5. Processos Computacionais ........................................................................................... 36
5.1 O PCB (Process Control Block) ............................................................................... 37
5.2 Estado do Processo ................................................................................................... 39
5.3 Mudanças de estado de Processo.............................................................................. 39
5.4 Tipos de Processos ................................................................................................... 39
5.5 Comunicação entre Processos .................................................................................. 40
5.5.1 PROBLEMAS DE SINCRONIZAÇÃO ............................................................ 40
5.5.2 SOLUÇÕES DE SOFTWARE........................................................................... 41
5.5.3 DEADLOCKS .................................................................................................... 43
6. Responda as seguintes Questões .................................................................................. 44
7. Aulas Prática ................................................................................................................ 48
8. Referências Bibliográficas e Sites................................................................................ 48
SISTEMAS OPERACIONAIS
Competência
1. Conhecer o funcionamento interno de um Sistema Operacional (S.O.), identificar sistemas
operacionais e programas utilitários de acordo com as necessidades do usuário, bem como analisar e
operar serviços e funções de sistemas operacionais e conhecer princípios, normas e recursos de
segurança em Informática.
Habilidades
1. Evolução de S.O.; Conceitos de S.O.; Classificação, Estrutura e Processos de Sistemas
Operacionais; Gerencia de Memória e Sistemas de Arquivos; Instalação de Sistemas Operacionais;
Configuração de Dispositivos (mouse, vídeo, modem, impressora e outros); Instalação,
desinstalação e configuração de softwares (aplicativos); Estrutura de Domínios e Contas;
Compartilhamento de Recursos; Segurança em S.O.; Tipos de Sistemas Operacionais; Sistemas
Operacionais Livres e Proprietários; Utilização do Prompt de Comandos.
3
APOSTILA E EXERCICIOS DA DISCIPLINA SISTEMA

OPERACIONAL
1. Introdução
Antes de começarmos a estudar os conceitos e os principais componentes de um sistema
operacional, devemos conhecer suas funções básicas.
Por mais complexo que possa parecer, um sistema operacional é apenas um conjunto de
rotinas executado pelo processador, da mesma forma que qualquer outro programa. Sua função
principal é controlar o funcionamento do computador, como um gerente dos diversos recursos
disponíveis no sistema.
Segundo Sobell, Sistema Operacional (SO) é um programa de controle do computador. Ele é
responsável por alocar recursos de hardware e escalonar tarefas. Ele também deve prover uma
interface para o usuário, ou seja, ele fornece ao usuário uma maneira de acesso aos recursos do
computador.
Segundo Stemmer, um SO pode ser definido como um gerenciador dos recursos que
compõem o computador (processador, memória, I/O, arquivos, etc). Os problemas centrais que o
sistema operacional deve resolver são: o compartilhamento ordenado, a proteção dos recursos a
serem usados pelas aplicações do usuário e o interfaceamento entre este e a máquina.
Um sistema operacional é um programa que controla a execução dos programas de aplicação
e atua como uma interface entre o usuário do computador e o hardware do computador. Um
sistema operacional pode ser pensado como tendo dois objetivos ou desempenhando duas funções:
conveniência, pois faz o sistema computacional mais conveniente de usar; e eficiência, pois permite
que os recursos do sistema computacional sejam usados de maneira eficiente [Stallings, 1996 apud
Jandl].
O SO é uma camada de software colocada entre o hardware e os programas que executam
tarefas para os usuários.
O SO busca ser mais eficiente (maior utilização do hardware; distribuição de recursos entre
os programas) e mais conveniente (diminuição de tempo para construção do programa; o acesso a
periféricos é feita pelo SO).
O SO oferece os seguintes tipos de serviços:
 Oferece meios para que um programa seja carregado na memória principal e executado.
O SO recebe o nome do arquivo, aloca na memória para o programa, copia o conteúdo
4
do arquivo para a memória principal, inicia sua execução, sendo possível abortar a
execução.
 Permite a utilização de arquivos, serviços implementados pelo Sistema de Arquivos.
Podendo criar, escrever, ler e destruir o arquivo. Através da leitura e escrita pode
renomear, obter tamanho, data e outras informações.
 Alocação de periféricos, leitura, escrita e liberação. Pode obter informações a respeito de
cada periférico e alterar algumas de suas características.
 Compartilhamento do computador. Podendo saber quanto e quais recursos cada usuário
necessita. Pode-se utilizar esta informação para calcular o valor a ser cobrado pelo uso
do computador, mesmo que não tenha esta cobrança, a monitoração do uso dos recursos
pode levar a identificação de gargalos no sistema.
 Informações sobre o sistema (data, hora, lista de usuários, versão do SO, etc).
 Mecanismos de proteção entre os usuários. Para não causar danos aos arquivos e
trabalhos do usuário.
O computador pode ser considerado como uma maquina de níveis ou camadas, tornando a
interação entre o usuário e o computador mais simples, confiável e eficiente. A parte física tornou-
se transparente para o usuário. Basicamente o computador possui a estrutura abaixo:
Figura 1 - Máquina de Níveis
Um sistema operacional possui inúmeras funções que resumimos em: Facilidade de acesso
aos recursos do sistema e Compartilhamento de recursos de forma organizada e protegida.
1.1 Facilidade de acesso aos recursos do sistema

Um sistema de computação, ao possuir, normalmente, diversos componentes, como
terminais, impressoras, discos e fitas. Quando utilizamos um desses dispositivos, não nos
preocupamos com a maneira como é realizada esta comunicação e os inúmeros detalhes envolvidos.
Para a maioria de nós uma operação cotidiana, como, por exemplo, a leitura de um arquivo
em disquete, pode parecer simples. Na realidade, existe um conjunto de rotinas específicas,
controladas pelo sistema operacional, responsável por acionar a cabeça, a de leitura e gravação da
5
unidade de disco, posicionar na trilha e setor onde estão os dados, transferir os dados do disco para
a memória e, finalmente, informar ao programa a chegada dos dados.
O sistema operacional, então, serve de interface entre os usuários e os recursos disponíveis
no sistema, tornando esta comunicação transparente e permitindo ao usuário um trabalho mais
eficiente e com menores chances de erros.
Este conceito de ambiente simulado, criado pelo sistema operacional, e denominado
máquina virtual (virtual machine) está presente, de alguma forma, na maioria dos sistemas atuais.
É comum pensar que compiladores, linkers1, bibliotecas, depuradores e outras ferramentas
fazem parte do sistema operacional, mas, na realidade, estas facilidades são apenas utilitários,
destinados a ajudar a interação do usuário com o computador.
1.2 Compartilhamento de recursos de forma organizada e protegida

Quando pensamos em sistemas multiusuários, onde vários usuários podem estar
compartilhando os mesmos recursos, como, por exemplo, memória e discos, é necessário que todos
tenham oportunidade de ter acesso a esses recursos, de forma que um usuário não interfira no
trabalho do outro.
Se imaginarmos, por exemplo, que uma impressora possa ser utilizada por vários usuários
do sistema, deverá existir algum controle para impedir que a impressão de um usuário interrompa a
impressão de outro. Novamente, o sistema operacional é responsável por permitir o acesso
concorrente a esse e a outros recursos, de forma organizada e protegida, dando ao usuário a
impressão de ser o único a utilizá-los.
O compartilhamento de recursos permite, também, a diminuição de custos, na medida em
que mais de um usuário possa utilizar as mesmas facilidades concorrentemente, como discos,
impressoras, linhas de comunicação etc.
Não é apenas em sistemas multiusuário que o sistema operacional é importante. Se
pensarmos que um computador pessoal nos permite executar várias tarefas, como imprimir um
documento, copiar um arquivo pela internet ou processar uma planilha, o sistema operacional deve
ser capaz de controlar a execução concorrentes dessas tarefas.
1
Linkers (ligadores) são programas capazes de juntar as diferentes partes de um mesmo programa, após elas
terem sido montadas separadamente. Isso permite, entre outras coisas, que programas grandes sejam divididos em
módulos que são montados separadamente e depois unidos em um só programa pelo ligador.
6
2. Um breve histórico dos Sistemas Operacionais

A evolução dos sistemas operacionais está, em grande parte, relacionada ao
desenvolvimento de equipamentos cada vez mais velozes, compactos e de custos baixos, e à
necessidade de aproveitamento e controle desses recursos.
Os primeiros sistemas de computação, no final dos anos 40 e início dos anos 50, não
possuíam sistema operacional. Por outro lado, os sistemas de computação atuais possuem sistemas
operacionais grandes, complexos e em constante evolução. A seguir são apresentados alguns dos
marcos mais relevantes na história dos sistemas operacionais:
Anos 40: cada programa executava sozinho e tinha total controle do computador. A carga
do programa em memória, a varredura dos periféricos de entrada para busca de dados, a
computação propriamente dita e o envio dos resultados para os periféricos de saída, byte a byte,
tudo devia ser programado detalhadamente pelo desenvolvedor da aplicação.
Nesta década não existia SO, o programador operadora todo o computador. Existe uma
planilha para alocação de horário na maquina. Durante o seu horário, o programado controla todo o
equipamento. Um programa, quando executado, tem controle total sobre a máquina, e acessa
diretamente os periféricos. No máximo, existe uma biblioteca com rotinas de E/S já programadas.
O programador passa a não operar mais o computador que durante a execução do programa
é entregue ao operador o seu job. O job é formado pelo programa a ser compilado e executado,
acompanhado dos dados para a execução. Os programas e dados são preparados na forma de cartões
perfurados. Após a execução o programador recebe uma listagem com a saída gerada pelo
programa. Caso haja erro durante a execução o operador pode tirar uma cópia na listagem do
conteúdo de toda memória principal (que não passa de poucos kilobytes). A depuração é feita pelo
programador.
Com os operadores profissionais diminui o tempo que o processo fica parado e enquanto
isso o programador pensa a solução para os erros. Para executar um job primeiro retira a fita
magnética, cartões e listagens do job que terminou e depois são preparadas as fitas magnéticas e os
cartões do próximo job. O tempo de execução ainda era grande, entao agruparam os Jobs em lotes
(ou batch). Onde os Jobs são colocados com necessidades semelhantes, exigindo pouca preparação
entre um Jobs do mesmo lote, surgindo assim o sistema em batch2.
2
Acompanhando a figura: inicialmente, os programas passaram a ser perfurados em cartões, que, submetidos a
uma leitora, eram gravados em uma fita de entrada (a). A fita, então, era lida pelo computador, que executava um
programa de cada vez, gravando o resultado do processamento em uma fita de saída (b). Ao terminar todos os
programas, a fita de saída era lida e impressa (c).
7
Figura 2 - Processamento Batch

A troca de Jobs continua sendo manual, feita pelo operador, quem tem que estar atento em
relação ao término de cada programa. Um mesmo job pode exigir a execução de vários programas.
Por exemplo, executar o montador traduzindo o código Assembly para linguagem de maquina, o
programa montado é ligado com as rotinas de E/S de uma biblioteca, o programa já pronto é
carregado e executado. Cada etapa é chamada de step.
Anos 50: Os primeiros sistemas surgiram, justamente para tentar automatizar as tarefas
manuais que eram utilizadas; eles passaram a ter seu próprio conjunto de rotinas para operações de
entrada e saída, eliminando a necessidade do programador desenvolver suas próprias rotinas de
leitura/gravação especificas para cada dispositivo periférico.
Os sistemas de computação fornecem “bibliotecas de sistema” (system libraries) que
encapsulam o acesso aos periféricos, para facilitar a programação de aplicações. Algumas vezes um
programa “monitor” (system monitor) auxilia a carga e descarga de aplicações e/ou dados entre a
memória e periféricos (geralmente leitoras de cartão perfurado, fitas magnéticas e impressoras de
caracteres).
Surgimentos dos transistores.
Surgiu o monitor residente que tinha a função de aumentar a transição do computador entre
programas. Era um programa que fica o tempo todo na memória. Quando um programa em
execução termina, ele avisa o monitor. O monitor, então, carrega automaticamente o próximo
programa e inicia a execução dele. A transição entre programas feita pelo monitor residente
dispensa a operação manual.
Para que o monitor residente saiba o que fazer, qual programa deve ser carregado, as
informações são passadas pelos cartões de controle, que também são utilizados para outras
informações. Estes cartões são a origem das linguagens de comandos.
8
O monitor residente também é o local indicado para as rotinas de acesso aos periféricos, são
rotinas utilizadas por todos os programas, com elas as aplicações não precisam acessar diretamente
os periféricos, apenas chamar a rotina apropriada dentro do monitor, iniciando a ideia de chamada
de sistema.
Anos 60: Surgiu o conceito de multiprogramação. No monitor residente, apenas um
programa é executado de cada vez. Quando ele precisa fazer alguma entrada e saída, o processador
fica parado. Em geral, periféricos são dispositivos eletromecânicos e trabalham na faixa de
milissegundo. Ao mesmo tempo, o processador é um dispositivo eletrônico, que trabalha na faixa de
microssegundo.
Decidiram então colocar vários programas na memória principal ao mesmo tempo, assim
enquanto um programa está esperando a conclusão da E/S o outro inicia sua execução
(multiprogramação). Desta forma o processador fica menos tempo parado e os periféricos são
melhor utilizados, pois com mais programas em execução, as solicitações são mais frequentes.
Surgem também as interrupções. Quando um comando é enviado para um periférico,
imediatamente o SO inicia a execução de um outro programa, sendo necessário que o periférico
avise o SO quando estiver concluído, isso se dá através das interrupções.
Técnica Polling ou busy-loop: Pode-se fazer com que o processador fique em um laço,
consultando a interface do periférico, até que a operação esteja concluída.
Não é possível fazer multiprogramação sem interrupções. O desenvolvimento dos discos
magnéticos também são importantes para o surgimento da multiprogramação. Os Jobs eram
submetidos em cartões perfurados e lidos pelo computador diretamente nos cartões, depois
passaram a ser copiados em fitas magnéticas. Com os discos magnéticos os Jobs dos cartões e fitas
passaram a ser lidos em discos, sendo agora possível a execução de vários Jobs.
Com a utilização de discos magnéticos, não havia mais a necessidade de reunir Jobs
semelhantes em lotes. O termo batch passou a designar um sistema no qual não existe interação
entre usuário e a execução do programa. Posteriormente o termo batch foi substituído por
“execução em background”. A depuração de programas em um ambiente batch é difícil. O
programador submete o job e, algumas horas depois, recebe uma listagem como o resultado da
execução. Os erros do programa devem ser detectados e corrigidos nesse contexto.
Nesta década também iniciou as primeiras experiências com sistemas timesharing, porem
somente na década seguinte ocorreu sua disseminação.
1961: o grupo do pesquisador Fernando Corbató, do MIT, anuncia o desenvolvimento do
CTSS – Compatible TimeSharing System, o primeiro sistema operacional com
compartilhamento de tempo.
9
1965: a IBM lança o OS/360, um sistema operacional avançado, com compartilhamento de

tempo e excelente suporte a discos.
1965: um projeto conjunto entre MIT, GE e Bell Labs define o sistema operacional Multics,
cujas idéias inovadoras irão influenciar novos sistemas durante décadas.
1966 – 1980: foram adicionados terminais e teclados para permitir interação entre o usuário
e o computador. Passa a ocorrer: Multiprogramação (enquanto o programa espera por uma
operação de leitura e gravação, o processador executa um outro programa, para tal a memória foi
dividida em partições, onde cada programa espera sua vez para ser executado), Spooling (com a
substituição das fitas por discos no processo de execução dos programas, o processamento se tornou
mais eficiente, permitindo a alteração da ordem na execução das tarefas, que eram seqüenciais),
TimeSharing (para melhorar o tempo de resposta razoáveis cada programa na memória utilizaria o
comutador em pequenos intervalos de tempo, compartilhando assim o processador com outros
programas).
Em um sistema TimeSharing, além da multiprogramação, cada usuário possui um terminal,
onde o usuário pode interagir com os programas em execução. E ao detectar um erro, ele corrige e
já inicia uma nova execução. Em termos de instruções de maquina, o tempo entre a digitação de
dois caracteres é muito grande, permitindo a execução de milhões de instruções de maquina (os
digitadores mais rápidos possuem a velocidade de 5 caracteres por segundo).
1969: Ken Thompson e Dennis Ritchie, pesquisadores dos Bell Labs, criam a primeira
versão do UNIX.
Na década de 80 houve uma enorme disponibilidade de microcomputadores, a medida que o
hardware era melhorado, o SO também era. Antes preocupava-se apenas com a eficiência no uso do
computador, porem iniciou uma grande preocupação com a conveniência, surgindo assim interfaces
mais amigáveis.
1981 – 1990: desenvolvimento da integração de circuitos em grande escala (LSI) e a
integração em muito larga escala (VLSI), aparecem chips com milhares de transistores
encapsulados em um centímetro quadrado de silício, nascendo daí a ideia de computador pessoal.
Cria-se os conceitos de multitarefas e multiprocessamento.
Devido ao avanço em redes de computadores, os softwares de rede passaram a estar
intimamente relacionados ao sistema operacional e surgem os sistemas operacionais de rede.
1981: a Microsoft lança o MS-DOS, um sistema operacional comprado da empresa Seattle
Computer Products em 1980.
1984: a Apple lança o sistema operacional Macintosh OS.
10
1985: primeira tentativa da Microsoft no campo dos sistemas operacionais com interface
gráfica, através do MS-Windows 1.0.
1987: Andrew Tanenbaum, um professor de computação holandês, desenvolve um sistema
operacional didático simplificado, mas respeitando a API do UNIX, que foi batizado como Minix.
1987: IBM e Microsoft apresentam a primeira versão do OS/2, um sistema multitarefa
destinado a substituir o MS-DOS e o Windows. Mais tarde, as duas empresas rompem a parceria; a
IBM continua no OS/2 e a Microsoft investe no ambiente Windows.
1991 – 2000: A VLSI (Very Large Scale Integration) evolui para ULSI (Ultra Large Scale
Integration). O conceito de processamento distribuído é explorado de forma que suas funções
estejam espalhadas por vários processadores através da rede de computadores. E a arquitetura
cliente-servidor aplicada basicamente em redes locais passa a ser oferecida em redes distribuídas.
Problemas de segurança, gerência e desempenho tornam-se fatores importantes relacionados ao
sistema operacional e a rede.
1991: Linus Torvalds, um estudante de graduação finlandês, inicia o desenvolvimento do
Linux, lançando na rede Usenet o núcleo 0.01, logo abraçado por centenas de programadores ao
redor do mundo.
1993: a Microsoft lança o Windows NT, o primeiro sistema 32 bits da empresa.
1993: lançamento dos UNIX de código aberto FreeBSD e NetBSD.
2001: a Apple lança o MacOS X, um sistema operacional derivado da família UNIX BSD.
2001: lançamento do Windows XP.
2004: lançamento do núcleo Linux 2.6.
2006: lançamento do Windows Vista.
2009: lançamento do Windows 7.
2012: lançamento do Windows 8.
Esse histórico reflete apenas o surgimento de alguns sistemas operacionais relativamente
populares; diversos sistemas acadêmicos ou industriais de grande importância pelas contribuições
inovadoras, como Mach, Chorus, QNX e Plan 9, não estão representados.
A maior parte das aplicações comerciais, mesmo em microcomputadores, é hoje construída
em torno de bancos de dados, mesmo que os sistemas gerenciadores de banco de dados sejam
implementados fora do SO.
Uma das áreas de pesquisa mais importantes atualmente é a dos sistemas operacionais
distribuídos, onde vários computadores são interconectados por meio de uma rede de comunicação
de algum tipo. A gerência dessas solicitações aumenta a complexidade do SO, fica mais difícil o
11
controle de acessos não autorizados e cria sérios problemas com segurança, principalmente após o
surgimento da Internet.
Outra área importante são os SO de tempo real usados no suporte as aplicações submetidas
de natureza temporal. Os sistemas mais simples estão os controladores embutidos em utilidades
domesticas (lavadoras de roupa e videocassetes), em outra extremidade, estão os sistemas militares
e o controle de trafego aéreo. Quanto a aplicações criticas estão os sistemas responsáveis pelo
monitoramente de pacientes em hospitais e os sistemas embarcados em veículos, de automóveis até
aviões e sondas espaciais. Em aplicações não criticas estão os vídeo-games e as aplicações
multimídia em geral.
Na tabela a seguir dividimos essa evolução em fases, onde destacamos, em cada uma, suas
principais características de hardware, software, interação com o sistema e aspectos de
conectividade.
Tabela 1 - Características por Fase

Fase Primeira Segunda Terceira Quarta Quinta
(1945-1955) (1956-1965) (1966-1980) (1981-1990) (1991- 2000)
Computadores ENIAC NCR IBM 360, 370 Cray XMP IBM 3090
EDVAC IMB 7094 PDP-11 IBM 308 Alpha AXP
UNIVAK CDC-6600 Cray 1 VAX-11 Pentium
Cyber-205 IBM-PC Sun SPARC
Hardware Válvulas Transistor Circuito Integrado LSI ou VLSI Ultra-LSI
Tambor Magnético Memória Magnética Disco Magnético Disco óptico Arquiteturas
Tubos de raios Minicomputador Microcomputador Paralelas
catódicos Microprocessador Circuto Integrado 3-
D
Software Linguagem de Linguagem de Alto Linguagem Multiprocessamento Processamento
Máquina Nível Estruturadas Sistemas Distribuído
Linguagem Processamento Batch Multiprogramação Especialistas Linguagens
assembly Time-Sharing Linguagens concorrentes
Computação Gráfica orientadas a objetos Programação
funcional
Linguagens naturais
Telecomunica- Telefone Transmissão Digital Comunicação via Redes Locais (LAN) Redes Locais
ções Teletipo satélite Internet estendidas (ELAN)
Microondas Redes sem fio
Redes Modelo cliente-
distribuídas(WAN) servidor
Fibra óptica
Desempenho 10 ips 200.000 ips 5 Mips 30 Mips 1 Gflops
1 Tflops
3. Tipos de Sistemas Operacionais
3.1 Classificação
Os Sistemas Operacionais podem ser classificados em:
 Sistemas monoprogramáveis/monotarefa - Single - Tasking: não admite ser usado
por mais de um usuário simultaneamente, gerenciando uma mesma CPU. O MSDOS, da Microsoft
é o SO monousuário mais utilizado até hoje.
12
 Sistemas Multiprogramáveis/Multitarefa: usuário executa mais de uma tarefa de

cada vez, permitindo que dois programas alternem o uso da CPU e de outros recursos. São
exemplos: UNIX, VMS, MS VS, G-COS, etc.
 Sistemas com múltiplos processadores: caracterizam-se por possuir duas ou mais
CPUs interligadas, trabalhando em conjunto, e podem ser:
* Fortemente acoplado, onde dois ou mais processadores compartilhando uma única
memória e controlados por apenas um único SO;
* Fracamente acoplado, no qual, dois ou mais sistemas de computação interligados, sendo
que cada sistema possui o seu próprio SO.
3.1.1 Sistema monoprogramável/ monotarefa

 São voltados a execução de um único programa (JOB)
 Outros programas deveriam aguardar o termino do programa corrente para ganhar o
processador
Características:
 Permitiam que o processador, a memória e I/O permanecessem exclusivos a
execução de um único programa (Mainframes).
 Processador ocioso.
 Memória e periféricos não eram utilizados em toda sua totalidade
 Implementação simples.
Os sistemas monotarefas se caracterizam por permitir que todos os seus recursos fiquem
exclusivamente dedicados a uma tarefa.
3.1.2 Sistema multiprogramável/ multitarefas

 Substituíram os sistemas monoprogramáveis/monotarefas.
Características:
 Mais complexos e eficientes.
 Vários programas dividindo os mesmos recursos.
 Preocupação do SO em gerenciar a concorrência no uso de CPU, memória e I/O.
Vantagens:
o Aumento de produtividade de seus usuários.
o Redução de custos por compartilhar vários recursos.
13
A partir do numero de usuários que interagem com o sistema, podemos classificar os

sistemas multiprogramáveis como monousuário e multiusuário.
No mundo dos computadores pessoais e estações de trabalho, apesar de existir apenas um
único usuário interagindo com o sistema (monousuário), é possível que ele execute diversas tarefas
concorrentemente ou mesmo simultaneamente.
Sistemas Multitarefas: permitem que o usuário edite um texto, imprima um arquivo, copie
um arquivo pela rede e calcule uma planilha.
Sist. Multiprog.
Multitarefas
Sistemas Batch Sistemas Time Sistemas Real Time

Sharing
Figura 3 - Tipos de Sistemas Multiprogramáveis
Os sistemas Multiprogramáveis/Multitarefas podem ser classificados em:

Sistema BATCH:
 Foram os 1º sistemas multiprogramáveis.
Características:
 Terem seus programas armazenados em discos e fitas, onde a execução é seqüencial.
 Normalmente não existem interações com os usuários.
Ex.: Compiladores, Linkedições, Sorts e Backups.
Sistemas de Tempo Compartilhado (Timesharing):

 Permitem interações do usuário com o sistema.
 Conhecidos como sistemas ON-LINE.
 Os periféricos e Dispositivos funcionam simultaneamente entre si, juntamente com a
CPU.
 Tarefas Concorrentes.
14
Ex.: verificar os arquivos armazenados no disco.

OBS.: Time – Slice é a fatia de tempo que o processador separa para cada processo que
deverá ser executado.
Vantagens:
 Redução de custos, aumento de produtividade.
Desvantagens:
 Desenvolvimento complexo.
Sistemas de Tempo (Real-time):

 Processamento e atualizações instantâneas
Ex.: controle de válvula de uma subestação petrolífera, controle de tráfego aéreo, controle de
usinas nucleares.
Vantagens:
 Atualizações instantâneas.
Desvantagens:
 Desenvolvimento complexo.
 Dedicação exclusiva ao processo.
Tabela 2 – Comparação de Sistemas Monousuários X Multiusuários

Monousuário Multiusuário
Não há compartilhamento de recursos Há compartilhamento de recursos
Um único usuário conectado Mais de um usuário conectado
Gerencia a própria maquina Gerencia remota
Não há correio eletrônico Há correio eletrônico
Sistemas Monoprogramáveis
 Somente um programa residente na memória
 CPU permanentemente dedicada a execução de um programa
 Desperdício na utilização da CPU
 Subutilização da memória
Sistemas Multiprogramáveis
15
 Vários programas podem estar residentes em memória, concorrendo pela utilização

da CPU
 A CPU permanece menos tempo ociosa
 Memória utilizada de forma mais eficiente
INTERRUPÇÃO E EXCEÇÃO
Eventos que podem ocorrer durante o processamento de um programa, obrigando a
intervenção do sistema operacional.
Pode ser resultado da execução de instruções do próprio programa, gerado pelo sistema
operacional ou por algum dispositivo de hardware.
O fluxo de execução do programa é desviado para uma rotina especial de tratamento.
- Interrupção
 Gerada pelo SO ou por algum dispositivo
 Independe do programa que está sendo executado
 Quando a interrupção é detectada, o controle é desviado para rotina de tratamento da
interrupção
 Através da interrupção o SO sincroniza a execução de todas as suas rotinas e dos
programas de usuário, além de controlar periféricos e dispositivos de sistema.
- Exceção
Resultado direto da execução de uma instrução do próprio programa.
Ex.: Divisão de um número por zero, overflow de caracteres.
O tratamento pode ser escrito pelo próprio programa.
OPERAÇÕES DE ENTRADA/SAÍDA (I/O ou E/S)

Controlador ou Interface faz a ligação entre a CPU e os periféricos.
- Controlador
Existem duas formas básicas do processador controlar as operações de E/S:
1ª - A UCP sincroniza-se com o periférico para inicio da transferência dos dados, após a
transferência o sistema fica permanente testando o estado do periférico para saber quando a
operação termina (busy wait).
- Controlado por programas, mantém a UCP ocupada até o termino da operação.
- Problemas: desperdício de tempo da UCP.
16
2ª - Após o inicio da transferência dos dados, a UCP fica livre para se ocupar de outras
tarefas. Em determinados intervalos de tempo o SO deve realizar um teste para saber do termino ou
não da operação de E/S em cada dispositivo (polling).
- Problema: se existir um grande numero de periféricos o SO terá que interromper o
processamento dos programas para testar os diversos periféricos.
- Canais de E/S
 Canais de E/S é um processador com capacidade de executar programas de E/S.
 As instruções de E/S são armazenadas na memória principal pela UCP.
 A UCP realiza uma operação de E/S instruindo o canal para executar um programa
localizado na memória.
 Canal E/S realiza a execução e ao final gera uma interrupção avisando o término da
operação.
BUFFERING
A técnica de buffering consiste na utilização de uma área da memória para a transferência de
dados entre periféricos e a memória principal denominado buffer (memória secundária).
O buffer possui a capacidade de armazenar diversos registros, de modo a permitir que
existam dados lidos no buffer mas ainda não processados, ou ainda não gravados. Desta forma, o
dispositivo de entrada poderá ler diversos registros antes que a CPU os processe, ou a CPU poderá
processar diversos registros antes de o dispositivo de saída realizar a gravação.
SPOOLING
Foi introduzido para aumentar a produtividade e eficiência dos sistemas operacionais.
Este processo permitia armazenar vários programas em uma fita para depois processá-los.
Atualmente, a técnica de spooling é implementada na maioria dos sistemas operacionais,
fazendo com que tanto a CPU quanto os dispositivos de E/S sejam aproveitados de forma mais
eficiente.
Um exemplo em impressoras, no momento em que um comando de impressão é executado
por um programa, as informações que serão impressas são gravadas em um arquivo de disco
(arquivos de spool), para ser impresso posteriormente pelo sistema.
Programa Sistema Impressão

Operacional
Arquivo de Spool
Figura 4 - Técnicas de Spooling
17
REENTRÂNCIA
Capacidade de um código de programa (código reentrante) poder ser compartilhado por
diversos usuários, exigindo que apenas uma cópia do programa esteja na memória.
Comum em sistemas multiprogramáveis, permite que cada usuário manipule dados próprios.
O código não pode ser mudado por nenhum usuário no momento em que está sendo
executado.
PROTEÇÃO
Essencial em sistemas multiprogramáveis para garantir a integridade dos pertencentes a cada
usuário.
Todo sistema implementa algum tipo de proteção ao diversos recursos que são
compartilhados, como memória, dispositivos de E/S e UCP.
3.1.3 Sistemas com múltiplos processadores

Possuem duas ou mais vias de CPUs interligadas, trabalhando em conjunto.
Fator-Chave: é a forma de comunicação entre as CPUs, o grau de compartilhamento da
memória e I/O.
Sist. Com Múltiplos

Processadores
Fortemente Fracamente
Acoplados Acoplados
Simétricos Assimétricos Redes Distribuídos
São
Figura 5 - Sistemas classificados
com em:
Múltiplos Processadores
Sistemas Fortemente Acoplados:

 Possuem dois ou mais processadores compartilhando uma única memória.
 Controlados por um único sistema Operacional.
Dividem-se em simétricos e assimétricos:
18
Assimétrico: Processador Mestre/Escravo (Master e Slave); Somente um processador Poe

executar serviços do sistema operacional.
Simétrico: Processadores com mesma função; Paralelismo (programa executado por vários
processadores ao mesmo tempo).
Organização Funcional
É o esquema de comunicação interna das CPUs, memória e I/O.
- Barramento Comum
Interliga todos os componentes em um único barramento.
Problema: Somente uma unidade funcional poderá estar utilizando o Barramento.
- Barramento Cruzado
Para evitar o problema de gargalo (no barramento) as unidades podem ser conectados entre
si. É possível a comunicação simultânea entre diferentes unidades funcionais, o hardware resolve os
conflitos de acesso a uma mesma unidade.
IMPORTANTE: a CPU não pode ter acesso simultâneo à uma mesma unidade de memória.
- Memória Multiport
Possibilita os acessos simultâneos a um modulo de memória.
Sistemas Fracamente Acoplados:

 Possuem dois ou mais sistemas de computação conectados através de linhas de
comunicação.
 Cada sistema possui seus próprios processadores, memória e dispositivos.
 Cada sistema possui seu próprio SO, gerenciando seus próprios recursos.
- S.O.R. (Sistema Operacional de Rede)

Cada nó possui seu próprio SO e possibilitam o compartilhamento de recursos além de
outras funções como:
o Cópia remota de arquivos;
o Emulação de terminal;
o Impressão remota;
o Gerencia remota;
o Correio eletrônico.
19
Cada nó é totalmente independente do outro, podendo possuir SOs diferentes.

Ex.: Windows NT, Linux, Win 98.
- SO Distribuído
Relacionamento forte entre os seus componentes, onde geralmente os SOs são os mesmos.
Ex.: Novell, Lantastic.
Organização Funcional
A organização funcional dos sistemas fracamente acoplados ou topologia define como são
interligadas fisicamente os diversos sistemas de rede.
- Barramento
Utilizadas em redes locais.
- Organização Distribuída
Linhas de comunicação ponto-a-ponto (Internet).
3.2 Alguns Tipos de Sistemas Operacionais

Batch (de lote): os sistemas operacionais mais antigos trabalhavam “por lote”, ou seja,
todos os programas a executar eram colocados em uma fila, com seus dados e demais informações
para a execução. O processador recebia os programas e os processava sem interagir com os
usuários, o que permitia um alto grau de utilização do sistema. Atualmente, este conceito se aplica a
sistemas que processam tarefas sem interação direta com os usuários, como os sistemas de
processamento de transações em bancos de dados. Além disso, o termo “em lote” também é usado
para designar um conjunto de comandos que deve ser executado em seqüência, sem interferência do
usuário. Exemplos desses sistemas incluem o OS/360 e VMS, entre outros.
De rede: um sistema operacional de rede deve possuir suporte à operação em rede, ou seja,
a capacidade de oferecer às aplicações locais recursos que estejam localizados em outros
computadores da rede, como arquivos e impressoras. Ele também deve disponibilizar seus recursos
locais aos demais computadores, de forma controlada. A maioria dos sistemas operacionais atuais
oferece esse tipo de funcionalidade.
Distribuído: em um sistema operacional distribuído, os recursos de cada máquina estão
disponíveis globalmente, de forma transparente aos usuários. Ao lançar uma aplicação, o usuário
interage com sua janela, mas não sabe onde ela está executando ou armazenando seus arquivos: o
20
sistema é quem decide, de forma transparente. Os sistemas operacionais distribuídos já existem há

tempos (Amoeba e Clouds, por exemplo), mas ainda não são uma realidade de mercado.
Multi-usuário: um sistema operacional multi-usuário deve suportar a identificação do
“dono” de cada recurso dentro do sistema (arquivos, processos, áreas de memória, conexões de
rede) e impor regras de controle de acesso para impedir o uso desses recursos por usuários não
autorizados. Essa funcionalidade é fundamental para a segurança dos sistemas operacionais de rede
e distribuídos. Grande parte dos sistemas atuais são multi-usuários.
Desktop: um sistema operacional “de mesa” é voltado ao atendimento do usuário doméstico
e corporativo para a realização de atividades corriqueiras, como edição de textos e gráficos,
navegação na Internet e reprodução de mídias simples. Sua principais características são a interface
gráfica, o suporte à interatividade e a operação em rede. Exemplos de sistemas desktop são:
Windows XP, MacOS X e Linux.
Servidor: um sistema operacional servidor deve permitir a gestão eficiente de grandes
quantidades de recursos (disco, memória, processadores), impondo prioridades e limites sobre o uso
dos recursos pelos usuários e seus aplicativos. Normalmente um sistema operacional servidor
também tem suporte a rede e multi-usuários.
Embutido: um sistema operacional é dito embutido (embedded) quando é construído para
operar sobre um hardware com poucos recursos de processamento, armazenamento e energia.
Aplicações típicas desse tipo de sistema aparecem em telefones celulares, controladores industriais
e automotivos, equipamentos eletrônicos de uso doméstico (leitores de DVD, TVs, fornos-micro-
ondas, centrais de alarme, etc.). Muitas vezes um sistema operacional embutido se apresenta na
forma de uma biblioteca a ser ligada ao programa da aplicação (que é fixa). Exemplos de sistemas
operacionais embutidos são o _C/OS, Xylinx, LynxOS e VxWorks.
Tempo real (real time): ao contrário da concepção usual, um sistema operacional de tempo
real não precisa ser necessariamente ultra-rápido; sua característica essencial é ter um
comportamento temporal previsível (ou seja, seu tempo de resposta deve ser conhecido no melhor e
pior caso de operação). A estrutura interna de um sistema operacional de tempo real deve ser
construída de forma a minimizar esperas e latências imprevisíveis, como tempos de acesso a disco e
sincronizações excessivas. Existem duas classificações de sistemas de tempo real: soft real-time
systems, nos quais a perda de prazos implica na degradação do serviço prestado. Um exemplo seria
o suporte à gravação de CDs ou à reprodução de músicas. Caso o sistema se atrase, pode ocorrer a
perda da mídia em gravação ou falhas na música que está sendo tocada. Por outro lado, nos hard
real-time systems a perda de prazos pelo sistema pode perturbar o objeto controlado, com graves
conseqüências humanas, econômicas ou ambientais. Exemplos desse tipo de sistema seriam o
21
controle de funcionamento de uma turbina de avião a jato ou de uma caldeira industrial. Exemplos
de sistemas de tempo real incluem o QNX, RT-Linux e VxWorks. Muitos sistemas embutidos têm
características de tempo real, e vice-versa.
4. Estrutura de Sistemas Operacionais

O SO é estruturado por um conjunto de rotinas que oferecem serviços aos usuários do
sistema e suas aplicações. Esse conjunto de rotinas é chamado de kernel (núcleo). Dentre as
principais funções do núcleo pode-se enumerar:
 Tratamento de interrupções;
 Criação e eliminação de processos;
 Sincronização e comunicação entre processos;
 Escalonamento e controle dos processos;
 Gerencia de memória;
 Gerencia do sistema de arquivos;
 Operações de I/O;
 Contabilização de segurança do sistema.
Arquitetura do SO é a imagem que o usuário tem do sistema, esta é formada pelas chamadas
de sistema e pelos programas de sistema.
- System Calls
Responsáveis por não permitir que a aplicação/usuário acessem diretamente o Kernel do SO,
mando assim, o sistema estável e operante. Estas chamadas à system calls por determinada
aplicação é similar à um programa modularizado ativando um de seus procedimentos ou funções.
Os programas solicitam serviços ao SO através das chamadas de sistema (System Calls).
Semelhante as chamadas de sub-rotinas, enquanto as chamadas de sub-rotinas são transferência para
procedimentos normais do programa, as chamadas de sistema transferem a execução para o SO. O
programa informa o que necessita através de parâmetros. O retorno da chamada de sistema e da
sub-rotina, faz com que a execução do programa seja retomada a partir de instruções que segue a
chamada.
O programador de Assembly chama as sub-rotinas de biblioteca. A lista de serviços do SO é
transformada em uma lista de chamadas de sistema (manual do SO).
A parte do SO responsável por implementar as chamadas de sistemas é chamada Núcleo ou
Kernel. Os principais componentes do Kernel são:
22
 Gerência de processos: Criação e eliminação de processos; alteração das

características do processo; sincronização e comunicação entre processos.
 Gerência de memória: Alocação e deslocação de memória.
 Gerência de entrada e saída (E/S): Operações de E/S; Manipulação de arquivos e
diretórios.
Devido a complexidade do Kernel, muitos SO são implementados em camadas. Assim, um
pequeno componente de software chamado micronúcleo ou microkernel implementa serviços mais
básicos do SO e usando seus serviços o Kernel implementa os demais.
Figura 6 - Organização do Sistema

Serviços do MicroKernel: gerencia do processador, alocação e liberação de memória física
e instalação de novos tratadores de dispositivos.
Serviços do Kernel: sistema de arquivos, memória virtual, protocolos de comunicação.
Os programas de sistema (utilitários) são programas normais fora do Kernel e fazem
chamadas de sistema assim como os aplicativos.
Na década de 60, compiladores faziam parte dos programas de sistema fornecidos com o
3
SO. Hoje você pode usar o SO de um fornecedor e compilador de outros, assim como
montadores4, interpretadores e editores de texto.
O programa de sistema Interpretador 5 de comandos é ativado pelo SO sempre que o usuário
inicia sua sessão de trabalho. Sua tarefa é receber comandos do usuário e executá-los. Para isso, ele
recebe as linhas tecladas e analisa o conteúdo e executa o comando teclado. Pode exigir uma ou
mais chamadas de sistema.
3
Compilador é um programa de sistema que traduz um programa descrito em uma linguagem de alto nível para
um programa equivalente em código de maquina para o processador (assembly). Exemplo: compiladores Java e C++.
4
O Montador traduz linguagem assembly para linguagem de maquina (em inglês Assembrer).
5
Interpretador de comandos, também conhecido como “shell”, é responsável por interpretar as instrucoes
enviadas pelo usuário e seus programas ao SO (o Kernel). Ele executa comandos de um arquivo executável. O
GNU/Linux possui diversos interpretadores de comando (bash, asch, csh, tcsh, sh) e o do DOS é o Command.com.
23
O SO oferece uma interface gráfica de usuário (GUI - Graphical User Interface) que
possibilita mais comodidade ao usuário, que passa a usar ícones, menus e mouse no lugar de digitar
comandos textuais.
Na maior parte do tempo, o usuário trabalha com programas distantes do SO e sua opinião a
respeito do sistema irá depender dos programas que utiliza.
Com o SO o usuário final obtêm maior eficiência e conveniência no uso do computador.
Normalmente o processador esta executando programas de usuário. Mas há 2 tipos de eventos que
ativam o SO: uma chamada de sistema ou uma interrupção de periféricos.
A chamada de sistema corresponde a uma solicitação de serviço por parte do programa em
execução. Por meio destas, o SO envia comandos para os controladores de periféricos. O
controlador deve informar ao SO quando a operação estiver concluída. Isso é feito por intermédio
de uma interrupção que acontece quando o processador para o que esta fazendo e passa a executar
uma rotina especifica do SO. A interrupção do periférico avisa o termino da operação de E/S,
dizendo assim que uma chamada de sistema foi concluída, liberando o processador para o programa
que estava a espera.
- Modos de Acesso
Operações como I/O e gerencia de memória são arriscadas e podem causar uma
instabilidade no SO, por isso aplicações não devem realizar este tipo de tarefa.
Para que uma aplicação possa realizar uma instrução privilegiada (que compromete o
sistema) são implementados pelo processador os modos de acesso:
 Modo Usuário: aplicação executa instrução não-privilegiada.
 Modo Kernel: aplicação executa instrução privilegiada.
4.1 Estrutura
Logicamente, nem todos os sistemas têm a mesma estrutura, ou seja, não apresentam a
mesma forma de ligação entre as partes. Contudo, os sistemas operacionais modernos geralmente
possuem as seguintes partes:
Gerenciamento de processos: Criar e eliminar, suspender e retomar, sincronismo
e comunicação entre processos; visa distribuir a capacidade do processamento de forma justa entre
as aplicações, evitando que uma aplicação monopolize esse recurso e respeitando as prioridades dos
usuários.
24
Gerenciamento da memória principal: Manter o controle das partes da memória

que estão sendo usadas e por quem, decidir que processos serão carregados para memória quando
houver espaço disponível, alocar e desalocar espaço de memória quando necessário;
Gerenciamento de memória secundária: O SO é responsável pelas atividades de
alocação de espaço livre, scheduling de disco;
Gerenciamento de Entrada/Saída: tem a função de implementar a interação com
cada dispositivo por meio de drivers e criar modelos abstratos que permitam agrupar vários
dispositivos distintos sob a mesma interface de acesso.
Gerenciamento de arquivos: Criar e eliminar arquivos e diretórios, manter
mapeamento dos arquivos em disco;
Proteção do sistema: Se um sistema é multiusuário e permite múltiplos processos
concorrentes, estes processos devem ser protegidos de outras atividades;
Networking: Em um sistema distribuído (fracamente acoplado) cada processador
tem sua própria memória e seus processadores que se comunicam através do SO. A comunicação
entre eles deve considerar roteamento e estratégias de conexão;
Interpretador de comandos: Um dos mais importantes programas do SO é o
interpretador de comandos, que serve de interface entre o usuário e o SO. Alguns SO’s incluem este
programa no próprio núcleo (kernel). Já outros sistemas, como o DOS e o UNIX, tratam o
interpretador de comandos como um programa especial que é executado quando uma sessão é
iniciada.
Com isso, um sistema operacional fornece um ambiente para execução, melhor dizendo,
fornece serviços para os programas e também para os usuários desses programas.
4.2 Funcionalidades
As funcionalidades do sistema operacional geralmente são inter-dependentes: por exemplo,
a gerência do processador depende de aspectos da gerência de memória, assim como a gerência de
memória depende da gerência de dispositivos e da gerência de proteção.
25
Figura 7 - Funcionalidades do Sistema Operacional

Alguns dos componentes mais relevantes de um sistema operacional típico são:
Núcleo: é o coração do sistema operacional, responsável pela gerência dos recursos do
hardware usados pelas aplicações. Ele também implementa as principais abstrações utilizadas pelos
programas aplicativos.
Drivers: módulos de código específicos para acessar os dispositivos físicos. Existe um
driver para cada tipo de dispositivo, como discos rígidos IDE, SCSI, portas USB, placas de vídeo,
etc. Muitas vezes o driver é construído pelo próprio fabricante do hardware e fornecido em forma
compilada (em linguagem de máquina) para ser acoplado ao restante do sistema operacional.
Código de inicialização: a inicialização do hardware requer uma série de tarefas
complexas, como reconhecer os dispositivos instalados, testá-los e configurá-los adequadamente
para seu uso posterior. Outra tarefa importante é carregar o núcleo do sistema operacional em
memória e iniciar sua execução.
Programas utilitários: são programas que facilitam o uso do sistema computacional,
fornecendo funcionalidades complementares ao núcleo, como formatação de discos e mídias,
configuração de dispositivos, manipulação de arquivos (mover, copiar, apagar), interpretador de
comandos, terminal, interface gráfica, gerência de janelas, etc.
26
Figura 8 - Estrutura de um sistema operacional
4.3 Proteção do núcleo

Um sistema operacional deve gerenciar os recursos do hardware, fornecendo-os às
aplicações conforme suas necessidades. Para assegurar a integridade dessa gerência, é essencial
garantir que as aplicações não consigam acessar o hardware diretamente, mas sempre através de
pedidos ao sistema operacional, que avalia e intermedeia todos os acessos ao hardware. Mas como
impedir as aplicações de acessar o hardware diretamente?
Núcleo, drivers, utilitários e aplicações são constituídos basicamente de código de máquina.
Todavia, devem ser diferenciados em sua capacidade de interagir com o hardware: enquanto o
núcleo e os drivers devem ter pleno acesso ao hardware, para poder configurá-lo e gerenciá-lo, os
utilitários e os aplicativos devem ter acesso mais restrito a ele, para não interferir nas configurações
e na gerência, o que acabaria desestabilizando o sistema inteiro. Além disso, aplicações com acesso
pleno ao hardware tornariam inúteis os mecanismos de segurança e controle de acesso aos recursos
(tais como arquivos, diretórios e áreas de memória).
Para permitir diferenciar os privilégios de execução dos diferentes tipos de software, os
processadores modernos contam com dois ou mais níveis de privilégio de execução. Esses níveis
são controlados por flags especiais nos processadores, e as formas de mudança de um nível de
execução para outro são controladas estritamente pelo processador.
O processador Pentium, por exemplo, conta com 4 níveis de privilégio (sendo 0 o nível mais
privilegiado), embora a maioria dos sistemas operacionais construídos para esse processador só use
os níveis extremos (0 para o núcleo e drivers do sistema operacional e 3 para utilitários e
aplicações). Na forma mais simples desse esquema, podemos considerar dois níveis básicos de
privilégio:
27
Nível núcleo: também denominado nível supervisor, sistema, monitor ou ainda kernel
space. Para um código executando nesse nível, todo o processador está acessível: todos os recursos
internos do processador (registradores e portas de entrada/saída) e áreas de memória podem ser
acessados. Além disso, todas as instruções do processador podem ser executadas. Ao ser ligado, o
processador entra em operação neste nível.
Nível usuário (ou userspace): neste nível, somente um sub-conjunto das instruções do
processador, registradores e portas de entrada/saída estão disponíveis. Instruções “perigosas” como
HALT (parar o processador) e RESET (reiniciar o processador) são proibidas para todo código
executando neste nível. Além disso, o hardware restringe o uso da memória, permitindo o acesso
somente a áreas previamente definidas. Caso o código em execução tente executar uma instrução
proibida ou acessar uma área de memória inacessível, o hardware irá gerar uma exceção6, desviando
a execução para uma rotina de tratamento dentro do núcleo, que provavelmente irá abortar o
programa em execução (e também gerar a famosa frase “este programa executou uma instrução
ilegal e será finalizado”, no caso do Windows).
É fácil perceber que, em um sistema operacional convencional, o núcleo e os drivers operam
no nível núcleo, enquanto os utilitários e as aplicações operam no nível usuário, confinados em
áreas de memória distintas.
4.4 Interrupções e Chamadas de Sistemas

O confinamento de cada aplicação em sua área de memória, imposto pelos mapeamentos de
memória realizados pela MMU (Unidade de Gerência de Memória - Memory Management
Unit) nos acessos em nível usuário, provê robustez e confiabilidade ao sistema, garantindo que uma
aplicação não poderá interferir nas áreas de memória de outras aplicações ou do núcleo. Entretanto,
essa proteção introduz um novo problema: como chamar, a partir de uma aplicação, as rotinas
oferecidas pelo núcleo para o acesso ao hardware e suas abstrações? A resposta a esse problema
está no mecanismo de interrupção.
Quando um controlador de periférico tem uma informação importante a fornecer ao
processador, ele tem duas alternativas de comunicação:
 Aguardar até que o processador o consulte, o que poderá ser demorado caso o
processador esteja ocupado com outras tarefas (o que geralmente ocorre);
6
As exceções ocorrem em eventos como instruções ilegais ou não existentes, tais como tentativa de divisão
por zero ou outros erros de software disparam exceções no processador, que resultam na ativação de uma rotina de
tratamento de exceção, usando o mesmo mecanismo das interrupções.
28
 Notificar o processador através do barramento de controle, enviando a ele uma

requisição de interrupção (IRQ – Interrupt ReQuest).
Ao receber a requisição de interrupção, os circuitos do processador suspendem seu fluxo de
execução corrente e desviam para um endereço pré-definido, onde se encontra uma rotina de
tratamento de interrupção (interrupt handler). Essa rotina é responsável por tratar a interrupção,
ou seja, executar as ações necessárias para atender o dispositivo que a gerou. Ao final da rotina de
tratamento da interrupção, o processador retoma o código que estava executando quando recebeu a
requisição.
O roteiro de ações ocorre a cada requisição de interrupção recebida pelo processador. Cada
interrupção geralmente corresponde a um evento ocorrido em um dispositivo periférico: a chegada
de um pacote de rede, um click no mouse, uma operação concluída pelo controlador de disco, etc.
Isso representa centenas ou mesmo milhares de interrupções recebidas por segundo, dependendo da
carga e da configuração do sistema (número e natureza dos periféricos). Por isso, as rotinas de
tratamento de interrupção devem ser curtas e realizar suas tarefas rapidamente (para não prejudicar
o desempenho do sistema).
Os processadores implementam uma instrução especial que permite acionar o mecanismo de
interrupção de forma intencional, sem depender de eventos externos ou internos. Ao ser executada,
essa instrução comuta o processador para o nível privilegiado e procede de forma similar ao
tratamento de uma interrupção. Por essa razão, esse mecanismo é denominado interrupção de
software ou trap. Processadores modernos oferecem instruções específicas para entrar/sair do
modo privilegiado e também um conjunto de registradores específicos para essa operação, o que
permite a transferência rápida do controle para o núcleo, com custo menor que o tratamento de uma
interrupção.
A ativação de procedimentos do núcleo usando interrupções de software (ou outros
mecanismos correlatos) é denominada chamada de sistema (system call ou syscall). Os
sistemas operacionais definem chamadas de sistema para todas as operações envolvendo o acesso a
recursos de baixo nível (periféricos, arquivos, alocação de memória, etc) ou abstrações lógicas
(criação e finalização de tarefas, operadores de sincronização e comunicação, etc). Geralmente as
chamadas de sistema são oferecidas para as aplicações em modo usuário através de uma biblioteca
do sistema (system library), que prepara os parâmetros, invoca a interrupção de software e
retorna à aplicação os resultados obtidos.
29
Figura 9 - Roteiro típico de uma chamada de sistema
A figura a acima ilustra o funcionamento básico de uma chamada de sistema (a chamada

read, que lê dados de um arquivo previamente aberto). Os seguintes passos são realizados:
1. No nível usuário, a aplicação invoca a função read da biblioteca de sistema.
2. A função read preenche uma área de memória com os parâmetros recebidos e escreve o
endereço dessa área em um registrador da CPU. Em outro registrador, ela escreve o código da
chamada de sistema.
3. A função read invoca uma interrupção de software (no caso do Linux, sempre é invocada
a interrupção 80h).
4. O processador comuta para o nível privilegiado (kernel level) e transfere o controle para
a rotina apontada pela entrada 80h do vetor de interrupções.
5. A rotina obtém o endereço dos parâmetros, verifica a validade de cada um deles e realiza
(ou agenda para execução posterior) a operação desejada pela aplicação.
6. Ao final da execução da rotina, eventuais valores de retorno são escritos na área de
memória da aplicação e o processamento retorna à função read, em modo usuário.
7. A função read finaliza sua execução e retorna o controle à aplicação.
8. Caso a operação solicitada não possa ser realizada imediatamente, a rotina de tratamento
da interrupção de software passa o controle para a gerência de atividades, ao invés de retornar
diretamente da interrupção de software para a aplicação solicitante. Isto ocorre, por exemplo,
quando é solicitada a leitura de uma entrada do teclado.
30
9. Na seqüência, a gerência de atividades devolve o controle do processador a outra

aplicação que também esteja aguardando o retorno de uma interrupção de software, e cuja operação
solicitada já tenha sido concluída.
A maioria dos sistemas operacionais implementa centenas de chamadas de sistema distintas,
para as mais diversas finalidades. O conjunto de chamadas de sistema oferecidas por um núcleo
define a API (Application Programming Interface) desse sistema operacional.
4.5 Sistemas monolíticos

São os mais comuns de serem encontrados, podem ser comparados a uma aplicação formada
por vários procedimentos compilados separadamente e linkados formando um único e grande
executável.
Aplic. Aplic.
SYSTEM CALLS
HARDWARE
Figura 10 - Sistemas Monolíticos
Em um sistema monolítico, todos os componentes do núcleo operam em modo núcleo e se

inter-relacionam conforme suas necessidades, sem restrições de acesso entre si, pois o código no
nível núcleo tem acesso pleno a todos os recursos e áreas de memória.
A grande vantagem dessa arquitetura é seu desempenho: qualquer componente do núcleo
pode acessar os demais componentes, toda a memória ou mesmo dispositivos periféricos
diretamente, pois não há barreiras impedindo esse acesso. A interação direta entre componentes
também leva a sistemas mais compactos.
Todavia, a arquitetura monolítica pode pagar um preço elevado por seu desempenho: a
robustez e a facilidade de desenvolvimento. Caso um componente do núcleo perca o controle
devido a algum erro, esse problema pode se alastrar rapidamente por todo o núcleo, levando o
sistema ao colapso (travamento, reinicialização ou funcionamento errático). Além disso, a
manutenção e evolução do núcleo se tornam mais complexas, porque as dependências e pontos de
interação entre os componentes podem não ser evidentes: pequenas alterações na estrutura de dados
31
de um componente podem ter um impacto inesperado em outros componentes, caso estes acessem
aquela estrutura diretamente.
A arquitetura monolítica foi a primeira forma de organizar os sistemas operacionais;
sistemas UNIX antigos e o MS-DOS seguiam esse modelo. Atualmente, apenas sistemas
operacionais embutidos usam essa arquitetura, devido às limitações do hardware sobre o qual
executam. O núcleo do Linux nasceu monolítico, mas vem sendo paulatinamente estruturado e
modularizado desde a versão 2.0 (embora boa parte de seu código ainda permaneça no nível de
núcleo).
4.6 Sistemas em Camadas

Um sistema em camada divide o SO em camadas sobrepostas. Cada módulo oferece um
conjunto de funções que podem ser utilizadas por outros módulos.
O primeiro sistema em camadas foi criado pelo Holandês Dijkstra, este sistema era
composto de seis camadas e foi posteriormente chamado de MULTICS (futuro UNICS – UNIX).
5 Operador
4 Programas de Usuários
3 I/O
2 Comunicação
1 Gerência de Memória
0 Multiprogramação
Figura 11 - Sistemas em Camadas

Uma forma mais elegante de estruturar um sistema operacional faz uso da noção de
camadas: a camada mais baixa realiza a interface com o hardware, enquanto as camadas
intermediárias provêem níveis de abstração e gerência cada vez mais sofisticados. Por fim, a
camada superior define a interface do núcleo para as aplicações (as chamadas de sistema). Essa
abordagem de estruturação de software fez muito sucesso no domínio das redes de computadores,
através do modelo de referência OSI (Open Systems Interconnection), e também seria de se
esperar sua adoção no domínio dos sistemas operacionais. No entanto, alguns inconvenientes
limitam sua aceitação nesse contexto:
 O empilhamento de várias camadas de software faz com que cada pedido de uma
aplicação demore mais tempo para chegar até o dispositivo periférico ou recurso a ser acessado,
prejudicando o desempenho do sistema.
32
 Não é óbvio como dividir as funcionalidades de um núcleo de sistema operacional

em camadas horizontais de abstração crescente, pois essas funcionalidades são inter-dependentes,
embora tratem muitas vezes de recursos distintos.
Em decorrência desses inconvenientes, a estruturação em camadas é apenas parcialmente
adotada hoje em dia. Muitos sistemas implementam uma camada inferior de abstração do hardware
para interagir com os dispositivos (a camada HAL – Hardware Abstraction Layer, implementada
no Windows NT e seus sucessores), e também organizam em camadas alguns sub-sistemas como a
gerência de arquivos e o suporte de rede (seguindo o modelo OSI). Como exemplos de sistemas
fortemente estruturados em camadas podem ser citados o IBM OS/2 e o MULTICS.
4.7 Sistemas Micronúcleo (Cliente-Servidor)

Os SOs modernos seguem a tendência de minimizar o tamanho do seu núcleo. Para
implementar esta ideia, o sistema é dividido em processos, sendo cada um responsável por oferecer
um conjunto de serviços, como, serviços de arquivo, serviços de criação de processos, serviços de
memória, serviços de escalonamento de processos, dentre outros.
Sempre que a aplicação deseja algum serviço, ela solicita ao processo responsável. A
aplicação que solicita o serviço é chamada de cliente, a que atende a solicitação é chamada de
servidor.
É função do kernel do sistema realizar a comunicação, ou seja, troca de mensagens entre o cliente e
o servidor.
CLIENTE SERV.ARQ SERV.MEM SERV.REDE
NÚCLEO
HARDWARE
Figura 12 - Sistemas Cliente-Servidor
Uma outra possibilidade de estruturação consiste em retirar do núcleo todo o código de alto
nível (normalmente associado às políticas de gerência de recursos), deixando no núcleo somente o
código de baixo nível necessário para interagir com o hardware e criar as abstrações fundamentais
(como a noção de atividade). Por exemplo, usando essa abordagem o código de acesso aos blocos
de um disco rígido seria mantido no núcleo, enquanto as abstrações de arquivo e diretório seriam
33
criadas e mantidas por um código fora do núcleo, executando da mesma forma que uma aplicação
do usuário.
Por fazer os núcleos de sistema ficarem menores, essa abordagem foi denominada micro-
núcleo (ou kernel). Um micro-núcleo normalmente implementa somente a noção de atividade, de
espaços de memória protegidos e de comunicação entre atividades.
Todos os aspectos de alto nível, como políticas de uso do processador e da memória, o
sistema de arquivos e o controle de acesso aos recursos são implementados fora do núcleo, em
processos que se comunicam usando as primitivas do núcleo.
Em um sistema micro-núcleo, as interações entre componentes e aplicações são feitas
através de trocas de mensagens. Assim, se uma aplicação deseja abrir um arquivo no disco rígido,
envia uma mensagem para o gerente de arquivos que, por sua vez, se comunica com o gerente de
dispositivos para obter os blocos de dados relativos ao arquivo desejado. Os processos não podem
se comunicar diretamente, devido às restrições impostas pelos mecanismos de proteção do
hardware. Por isso, todas as mensagens são transmitidas através de serviços do micro-núcleo. Como
os processos têm de solicitar “serviços” uns dos outros, para poder realizar suas tarefas, essa
abordagem também foi denominada cliente-servidor.
O micro-núcleos foram muito investigados durante os anos 80. Dois exemplos clássicos
dessa abordagem são os sistemas Mach e Chorus. As principais vantagens dos sistemas micro-
núcleo são sua robustez e flexibilidade: caso um sub-sistema tenha problemas, os mecanismos de
proteção de memória e níveis de privilégio irão confiná-lo, impedindo que a instabilidade se alastre
ao restante do sistema. Além disso, é possível customizar o sistema operacional, iniciando somente
os componentes necessários ou escolhendo os componentes mais adequados às aplicações que serão
executadas.
Vários sistemas operacionais atuais adotam parcialmente essa estruturação; por exemplo, o
MacOS X da Apple tem suas raízes no sistema Mach, ocorrendo o mesmo com o Digital UNIX.
Todavia, o custo associado às trocas de mensagens entre componentes pode ser bastante elevado, o
que prejudica seu desempenho e diminui a aceitação desta abordagem. O QNX é um dos poucos
exemplos de micro-núcleo amplamente utilizado, sobretudo em sistemas embutidos e de tempo-
real.
4.8 Máquinas Virtuais

Para que programas e bibliotecas possam executar sobre uma determinada plataforma
computacional, é necessário que tenham sido compilados para ela, respeitando o conjunto de
instruções do processador e o conjunto de chamadas do sistema operacional.
34
Da mesma forma, um sistema operacional só poderá executar sobre uma plataforma de

hardware se for compatível com ela. Nos sistemas atuais, as interfaces de baixo nível são pouco
flexíveis: geralmente não é possível criar novas instruções de processador ou novas chamadas de
sistema, ou mudar sua semântica. Por isso, um sistema operacional só funciona sobre o hardware
para o qual foi construído, uma biblioteca só funciona sobre o hardware e sistema operacional para
os quais foi projetada e as aplicações também têm de obedecer a interfaces pré-definidas.
Todavia, é possível contornar os problemas de compatibilidade entre os componentes de um
sistema através de técnicas de virtualização. Usando os serviços oferecidos por um determinado
componente do sistema, é possível construir uma camada de software que ofereça aos demais
componentes serviços com outra interface. Essa camada permitirá assim o acoplamento entre
interfaces distintas, de forma que um programa desenvolvido para uma plataforma A possa executar
sobre uma plataforma distinta B. O sistema computacional visto através dessa camada é
denominado máquina virtual.
Figura 13 - Uma Maquina Virtual

Um ambiente de máquina virtual consiste de três partes básicas:
 O sistema real, ou sistema hospedeiro (host system), que contém os recursos reais de
hardware e software do sistema;
 O sistema virtual, também denominado sistema convidado (guest system), que
executa sobre o sistema virtualizado; em alguns casos, vários sistemas virtuais podem coexistir,
executando sobre o mesmo sistema real;
 A camada de virtualização, denominada hipervisor ou monitor de virtualização
(VMM - Virtual Machine Monitor), que constrói as interfaces virtuais a partir da interface real.
35
5. Processos Computacionais
Um processo computacional ou simplesmente processo pode ser entendido como uma
atividade que ocorre em meio computacional, usualmente possuindo um objetivo definido, tendo
duração finita e utilizando uma quantidade limitada de recursos computacionais.
Então, podemos entender um processo como um programa em execução, o que envolve o
código do programa, os dados em uso, os registradores do processador, sua pilha (stack) e o
contador de programa além de outras informações relacionadas a sua execução. Desta forma, temos
que a impressão de um documento é um processo computacional assim como a cópia de um
arquivo, a compilação de um programa ou a execução de uma rotina qualquer. Todas as atividades,
manuais ou automáticas, que ocorrem dentro de um computador podem ser descritas como
processos computacionais.
Atualmente quase todos os computadores são capazes de realizar diversas tarefas ao mesmo
tempo, onde cada uma destas tarefas pode representar um ou mais processos. Para funcionarem
desta forma tais computadores são multiprogramados, ou seja, o processador é chaveado de
processo em processo, em pequenos intervalos de tempo, isto é, o processador executa um
programa durante um pequeno intervalo de tempo, para depois executar outro programa por outro
pequeno intervalo de tempo e assim sucessivamente.
Num instante de tempo qualquer, o processador estará executando apenas um dado
programa, mas durante um intervalo de tempo maior ele poderá ter executado trechos de muitos
programas criando a ilusão de paralelismo.
Este comportamento é, algumas vezes, chamado de paralelismo virtual ou
pseudoparalelismo. Em computadores com dois ou mais processadores é possível a existência de
paralelismo verdadeiro, pois cada processador pode executar um processo independentemente.
A administração de vários diferentes programas em execução concomitante é o que permite
o funcionamento eficiente dos computadores modernos, ao mesmo tempo conferindo-lhe complexa
organização e estrutura, pois tal administração não é simples e requer a consideração de muitos
fatores e situações diferentes, mesmo que improváveis.
O termo processo (process) é muitas vezes substituído pelo termo tarefa (task), foi
utilizado pela primeira vez no desenvolvimento do MULTICS, na década de 60, e pode assumir um
dos seguintes significados:
 Um programa em execução;
 Uma atividade assíncrona;
 O espírito ativo de um procedimento;
 O “controle local” de um procedimento em execução;
36
 Entidade para o qual o processador está dedicado.

Outro ponto importante é que os processos computacionais podem ser divididos em sub-
processos, ou seja, podem ser decompostos em processos componentes mais simples que o
processo como um todo, o que permite um detalhamento da de sua tarefa ou do seu modo de
operação. Esta análise aprofundada dos processos através de sua decomposição em sub-processos
pode ser feita quase que indefinidamente, até o exagerado limite das micro-instruções do
processador que será utilizado. O nível adequado de divisão de um processo é aquele que permite
um entendimento preciso dos eventos em estudo, ou seja, depende do tipo de problema em questão
e também da solução pretendida.
Processos também podem criar novos processos. O processo criador é chamado de
processo-pai (parent process) enquanto os processos criados são denominados de processos
filhos (child process). Um processo filho também pode criar novos processos, permitindo a
criação de árvores de processos hierarquicamente relacionados.
É importante estudarmos os processos computacionais porque a razão de ser dos
computadores é a realização de certas atividades de maneira mais rápida e confiável do que seria
possível para o homem. Como cada processo precisa de recursos para ser executado e concluído, a
ocorrência de processos significa a utilização de recursos do computador. Sendo assim, para que um
sistema operacional possa cumprir com seu papel de gerente de recursos de um sistema
computacional é fundamental um entendimento mais profundo dos processos computacionais e de
suas particularidades como forma efetiva de criar-se sistemas operacionais capazes de lidar com as
exigências dos processos em termos de recursos.
5.1 O PCB (Process Control Block)

O PCB é uma estrutura de dados que contem importantes informações sobre os processos
incluso.
Ponteiro
Estado do Processo
Nome do Processo
Prioridade do Processo
Registradores
Limites de Memória
Lista de Arquivos Abertos
Figura 14 - Bloco de Controle de Processo
37
O SO gerencia os processos através das system calls que realizam operações como criação,
eliminação, sincronização, suspensão de processos, dentre outros.
Pelo motivo dos PCBs precisarem ser manipulados rapidamente pelo SO, muitos sistemas de
computadores, contém registradores que sempre mostram ao PCB qual o processo em execução. As
instruções de hardware estão frequentemente disponível para carregar informações dentro do PCB e
recuperar essas informações rapidamente.
CONTEXTO DE HARDWARE
Constitui-se basicamente do conteúdo dos registradores, Program Counter (PC), Stack Point
(SP) e bits de estado. Quando um processo está em execução seu contexto de hardware fica gravado
nos registradores do processador. No instante em que o processo perde a utilização da CPU, o
sistema salva suas informações no contexto de hardware do processo.
Este contexto é aplicado a sistemas que utilizam-se de Time-Sharing, podendo ser
interrompido e recuperado como se nada tivesse acontecido.
CONTEXTO DE SOFTWARE
São características de um processo que vão influenciar na execução de um programa, como
por exemplo n.o máximo de arquivos abertos simultaneamente e o tamanho do buffer 7para as
operações de I/O.
Um processo contem 3 grupos, de informações, são eles:
- Identificação: os processos criados recebem sempre uma identificação (PID) e em alguns
sistemas podem receber além do PID um nome também.
- Quotas: são limites de cada recurso do sistema que um processo pode alocar. Caso uma
quota não seja o suficiente o processo é executado lentamente ou até não ser executado. Ex.: n o
máximo de arquivos abertos simultaneamente, tamanho máx. de memória que um processo pode
alocar, no máximo de operações de I/O pendentes, tamanho máx. do buffer para operação de I/O, no
máx. de processos e sub-processos que podem ser criados.
- Privilégios: determina o que os processos podem ou não fazer em relação ao sistema ou a
outros processos.
ESPAÇO DE ENDEREÇAMENTO
É a área de memória do processo onde o programa é executado, além do espaço para os
dados utilizados por ele.
7
Buffer é uma área de armazenamento em memória principal para transferências de I/O.
38
5.2 Estado do Processo

Durante a existência de um processo, ele passa por vários estados:
 Execução (Running): Processo na CPU.
 Pronto (Ready): Aguarda uma oportunidade para ser executado.
 Espera (Waint): Aguarda algum evento externo ou algum recurso para poder
prosseguir seu processamento.
O SO gerencia processos através de listas encadeadas, onde cada PCB tem um ponteiro para
seu sucessor. Sendo assim, existe uma lista para cada estado do processo.
5.3 Mudanças de estado de Processo

Pronto  Execução: Aguarda a oportunidade para ser executado.
Execução  Espera: Aguarda a conclusão do evento solicitado. Ex.: I/O.
Espera  Pronto: Operação solicitada é atendida e ele deve retornar a execução. Obs.: um
processo em espera obrigatoriamente volta ao estado de pronto antes de ser executado novamente.
Execução  Pronto: passa do estado de pronto sempre que for um evento, pelo sistema.
Ex.: Fim da fatia de tempo para este processo.
5.4 Tipos de Processos

Os programas podem ser classificados de acordo com o tipo de processamento que realiza:
CPU – bound (Ligado a CPU): Quando passa a maior parte do tempo no estado de
execução.
I/O – bound (Ligado a I/O): Maior parte do tempo no estado de espera, pois realiza um
elevado numero de I/O.
Um critério muito importante de análise dos processos computacionais é aquele que
considera os processos segundo sua ocorrência, isto é, a observação de seu comportamento
considerando o tempo. Neste caso teríamos os seguintes tipos de processos:
 Sequenciais: São aqueles que ocorrem um de cada vez, um a um no tempo,
serialmente, como que de forma exclusiva.
 Paralelos: aqueles que, durante um certo intervalo de tempo, ocorrem
simultaneamente, ou seja, aqueles que no todo ou em parte ocorrem ao mesmo tempo.
39
5.5 Comunicação entre Processos

Os processos que trabalham junto geralmente compartilham recursos como arquivos,
registros, dispositivos e áreas de memória. Esse compartilhamento de recurso pode gerar situações
indesejáveis, capazes de comprometer todo o sistema.
Ex.: dois processos concorrentes trocam informações de operações de gravação e leitura em
um buffer. Um processo só pode gravar dados no buffer caso ele não esteja cheio. Da mesma forma,
um processo só poderá ler os dados armazenados se eles existirem no buffer.
Os mecanismos que garantem a comunicação entre processos concorrentes e o acesso a
recursos compartilhados são chamados mecanismos de sincronização. Este mecanismo é
fundamental para projetos de SOs multiprogramáveis.
A primeira notação para especificação de concorrência de um programa foram os comandos
FORK (criação de processo) e JOIN (sincronização de processo).
A solução mais simples para evitar problemas de compartilhamento é impedir que dois ou
mais processos acessem os mesmos recursos no mesmo instante. Essa ideia de exclusividade é
chamada de EXCLUSAO MÚTUA.
A exclusão mútua deve apenas afetar os processos concorrentes quando um deles estiver
fazendo acesso ao recurso compartilhado é denominada de REGIÃO CRÍTICA.
5.5.1 PROBLEMAS DE SINCRONIZAÇÃO

Na tentativa de implementação de exclusão, algumas soluções introduzem novos problemas,
que chamaremos de problemas de sincronização.
- Velocidade de execução dos processos: pode interferir em uma solução para o problema
de exclusão mútua.
- Starvation: é a situação onde um processo nunca consegue executar sua região critica e,
consequentemente, acessar o recurso compartilhado. Este problema ocorrer quando dois ou mais
processos esperam por um recurso alocado. No momento em que o recurso é liberado, o sistema
deve determinar qual processo ganhará o acesso ao recurso. Caso essa escolha seja aleatória, existe
a possibilidade de um processo nunca ser escolhido e sofrer starvation.
- Sincronização Condicional: outra situação na qual é necessária a sincronização entre
processos concorrentes é quando um recurso compartilhado não se encontra pronto para ser
utilizado pelos processos. Nesse caso, o processo que deseja acessar o recurso deverá ser colocado
no estado de espera, até o recurso ficar pronto para o procedimento. Esta sincronização é também,
conhecida como problema do produtor/consumidor.
40
5.5.2 SOLUÇÕES DE SOFTWARE

Além da exclusão mútua, que soluciona os problemas de compartilhamento de recursos, três
fatores mais devem ser levados em conta para a solução dos problemas de sincronização:
 Numero de processadores e tempo de execução dos processos concorrentes devem
ser irrelevantes;
 Um processo, fora de sua região critica, não pode impedi que outros processos
entrem em sua próprias regiões criticas;
 Um processo não pode permanecer indefinidamente esperando para entrar em sua
região critica.
A seguir estão relacionadas algumas ferramentas de software utilizadas para a solução dos
problemas de sincronização entre processos.
- Semáforos
Conceito de semáforos foi proposto por Dijkstra, como uma das soluções geral mais simples
de ser implementada. Um semáforo é uma variável inteira, não negativa, que só Poe ser manipulada
por duas instruções: DOWN e UP, também chamadas originalmente de P e V.
No caso da exclusão mútua, as instruções DOWN e UP funcionam como protocolos de
entrada e saída. O semáforo fica associado a um recurso compartilhado, indicando quando o recurso
está sendo acessado por um processo concorrente. Se seu valor for maior que 0, então nenhum
processo está utilizando o recurso, caso contrario, o processo fica impedido de acesso.
O programa a seguir mostra uma solução para os problemas da exclusão mútua entre dois
processos através do uso de semáforos.
PROGRAM Semaforo_1; repeat
var Down(s);
s: semáforo := 1; Regiao_critica_B;
procedure processo_A; Up(s);
begin until false;
repeat end;
down (s); //desocupa a região
Regiao_Critica_A; begin
Up(s); //ocupa a região parbegin
until false; processo_A;
end; processo_B;
parend;
procedure processo_B; end.
begin
41
Semáforos aplicados ao problema de exclusão mútua são chamados mutexes (mutual

exclusion semaphones) ou binários, por apenas assumirem os valores 0 e 1.
- Monitores
São mecanismos de sincronização de alto nível tentando tornar mais fáceis o
desenvolvimento e a correção de programas concorrentes.
O monitor é um conjunto de procedimentos, variáveis e estrutura de dados definido dentro
do módulo. Sua característica mais importante é a implementação automática da exclusão mútua
entre procedimentos do monitor em um determinado instante. Toda vez que algum processo chama
um desses procedimentos do monitor. Caso exista, o processo ficará aguardando a sua vez até que
tenha permissão para executar.
- Troca de Mensagens
É um mecanismo de comunicação e sincronização entre processos, implementado pelo
sistema operacional através de duas rotinas do sistema: SEND e RECEIVE. A rotina SEND é
responsável por enviar uma mensagem para um processo receptor, e a rotina RECEIVE por receber
uma mensagem de um processo transmissor. As rotinas podem ser representadas através dos
procedimentos a seguir:
SEND (Receptor, Mensagem);
RECEIVE(Transmissor, Mensagem);
A comunicação ocorre porque um processo, ao receber uma mensagem, obtém dados
enviados de outro processo. A sincronização é obtida porque uma mensagem obtém dados enviados
de outro processo. A sincronização é obtida porque uma mensagem somente pode ser lida após ter
sido enviada, restringindo, dessa forma, a ordem na qual os dois eventos devem ocorrer.
A comunicação por troca de mensagens possui muitos problemas, como a perda de uma
mensagem. Para evitar que esta mensagem não se perca o processo receptor deve enviar ao processo
transmissor uma mensagem de recebimento (ACK – acknowledgement). Caso o transmissor não
receba o ACK ele retransmite a mensagem.
O endereçamento direto é a troca de mensagem entre dois processos diretamente.
O endereçamento indireto é a troca de mensagem entre dois processos utilizando um
intermediário mailbox.
42
5.5.3 DEADLOCKS
Um processo é dito em deadlock quando está esperando por um evento que nunca ocorrerá.
Essa situação é conseqüência do comportamento de recursos do sistema entre vários processos,
sendo que cada processo deve ter acesso ao recurso de forma exclusiva (exclusão mútua).
O problema de deadlock existe em qualquer sistema multiprogramável, no entanto, as
soluções implementadas devem considerar o tipo do sistema e o impacto em seu desempenho.
- Prevenção de Deadlock
Para prevenir o deadlock é necessário uma das quatro condições abaixo:
 Exclusão mútua.
 Evitar que os processos que já possuam recursos garantidos requisitem novos
recursos, também evitarem o problema do deadlock.
 Permitir que um recurso seja retirado de um processo quando outro processo
necessitar do mesmo recurso.
 Forçar o processo a ter apenas um recurso de cada vez.
- Detecção de Deadlock
Os sistemas operacionais para detectar deadlocks, devem manter estruturas de dados capazes
de identificar cada recurso do sistema, o processo que o está alocando que estão na espera da
liberação do recurso. Toda vez que um recurso é alocado ou liberado por um processo, a estrutura
deve ser atualizada.
Dependendo do tipo de sistema, o ciclo de busca por um deadlock varia. Em sistemas com
time sharing, o tempo de busca pode ser maior, sem comprometer o desempenho e a confiabilidade
do sistema. Já em sistemas de tempo real devem constantemente certificar-se da ocorrência de
deadlocks, porém essa maior segurança gera mais processamento no sistema.
- Correção de Deadlock
Uma solução bastante utilizada na maioria dos SOs é eliminar os processos envolvidos no
deadlocks e desalocar os recursos já garantindo por eles, quebrando assim a espera circular.
43
6. Responda as seguintes Questões

1) Cite as características dos Sistemas Operacionais Monogramáveis/ monotarefa.
2) Cite as características dos Sistemas Operacionais Multiprogramáveis/ multitarefa.
3) Cite e explique um dos tipos de sistemas multiprogramáveis.
4) Faça a comparação entre sistemas mono e multiusuários.
5) Diferencie Sistemas Fortemente Acoplados Simétricos de Assimétricos.
6) Diferencie Sistema Operacional de Rede de Sistema Operacional Distribuído.
7) Quais funções devem ser oferecidas por um SO de rede?
8) Diferencie Interrupção de Exceção.
9) Explique o processo de Spooling.
10) O que Buffering?
11) Defina o que é reentrância.
12) Diferencie Barramento comum de Barramento Cruzado.
13) Sobre o Kernel (núcleo do sistema), marque a opção que contem uma função que não é
atribuição do SO:
a) Tratamento de interrupções d) Gerencia do sistema de arquivos
b) Criaçao e eliminação de processos e) Gerencia de memória
c) Processamento rápido de dados
14) Sobre as System Calls, marque a alternativa que contem uma afirmação INCORRETA:
a) São responsáveis por impedir acesso direto d) É o método pelo qual o SO gerencia
ao kernel. processos.
b) São interrupções que o SO causa no e) NDA
momento de falha de uma aplicação.
c) São responsáveis por manter o Kernel
estável.
15) Sobre os sistemas cliente-servidor, assinale a alternativa INCORRETA:

a) O sistema é dividido em processos cada um responsável por oferecer um conjunto de serviços.
b) A aplicação que solicita o serviço é chamada cliente e a que atende a solicitação é chamada
servidor.
c) É função do SO realizar a comunicação entre o cliente e o serviço.
d) É função do processador realizar a comunicação entre o cliente e o serviço.
44
16) sobre os grupo de System Calls, ligue as colunas:

(1) Gerência de Memória ( ) Criação de processos
(2) Gerência de I/O ( ) Eliminação de processos
(3) Gerência de Processos ( ) Comunicação entre processos
( ) Manipulação de arquivos e diretórios
( ) Alocação de memória
( ) Operações de Entrada e Saída
17) Sobre os estados de um processo, marque a alternativa INCORRETA:

a) Um processo está em execução quando está na memória.
b) Um processo está pronto quando aguarda uma oportunidade para ser executado.
c) Um processo está em espera quando aguarda um evento externo para prosseguir seu
processamento.
d) Um processo está em execução quando está na CPU.
e) Um processo está pronto quando terminou sua execução.
18) Explique o principio da Exclusão Mútua.

19) Explique o que é starvation.
20) Explique o que são deadlocks.
21) Quais os métodos para prevenção de deadloacks?
22) O que é contexto de software?
23) Quais as principais funções dos sistemas operacionais?
24) Por que a abstração de recursos é importante para os desenvolvedores de aplicações? Ela tem
utilidade para os desenvolvedores do próprio sistema operacional?
25) A gerência de atividades permite compartilhar o processador, executando mais de uma
aplicação ao mesmo tempo. Identifique (por meio de pesquisas) as principais vantagens
trazidas por essa funcionalidade e os desafios a resolver para implementá-la.
26) O que caracteriza um sistema operacional de tempo real? Quais as duas classificações de
sistemas operacionais de tempo real e suas diferenças?
27) O que diferencia o núcleo do restante do sistema operacional?
45
28) Seria possível construir um sistema operacional seguro usando um processador que não tenha
níveis de privilégio? Por quê?
29) Monte uma tabela com os benefícios e deficiências mais significativos das principais
arquiteturas de sistemas operacionais.
30) Relacione as afirmações aos respectivos tipos de sistemas operacionais: distribuído (D), multi-
usuário (M), desktop (K), servidor (S), embutido (E) ou de tempo-real (T):
[ ] Deve ter um comportamento temporal previsível, ou seja, com prazos de resposta bem
definidos.
[ ] A localização dos recursos do sistema é transparente para os usuários.
[ ] Todos os recursos do sistema têm proprietários e existem regras controlando o acesso aos
mesmos pelos usuários.
[ ] A gerência de energia é muito importante neste tipo de sistema.
[ ] Prioriza a gerência da interface gráfica, recursos multimídia e a interação com o usuário.
[ ] Construído para gerenciar de forma eficiente grandes volumes de recursos.
[ ] São sistemas operacionais compactos, construídos para executar sobre plataformas com poucos
recursos.
31) A operação em modo usuário permite ao processador executar somente parte das instruções
disponíveis em seu conjunto de instruções. Quais das seguintes operações não deveria ser
permitida em nível usuário? Por quê?
(a) Ler uma porta de entrada/saída
(b) Efetuar uma divisão inteira
(c) Escrever um valor em uma posição de memória
(d) Ajustar o valor do relógio do hardware
(e) Ler o valor dos registradores do processador
(f) Mascarar uma ou mais interrupções
32) Quais as diferenças entre interrupções, exceções e traps?

33) Qual a função da memória principal?
34) O que é uma instrução privilegiada?
35) Cite os sistemas de camadas?
36) O que é kernel monolítico?
37) Qual a melhor definição para processo?
38) Defina os estados de um processo.
46
39) Comente os comandos Fork e Join.

40) O que é uma região critica?
41) Qual a diferença entre endereçamento direto e indireto?
42) Comente sobre monitores e trocas de mensagens.
43) Qual a diferença entre compilador, tradutor e interpretador?
44) Explique o funcionamento do processamento Batch.
45) Qual a melhor definição de SO?
46) Quais os três principais estados de um processo? Descreva os eventos que fazem com que um
processo mude de estado.
47

Sistema Operacional SO

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Sistema Operacional SO

Enviado por

Direitos autorais:

Formatos disponíveis

www.cliqueapostilas.com.

APOSTILA E EXERCICIOS DA DISCIPLINA SISTEMA

Figura 1 - Máquina de Níveis

1.1 Facilidade de acesso aos recursos do sistema

1.2 Compartilhamento de recursos de forma organizada e protegida

2. Um breve histórico dos Sistemas Operacionais

Figura 2 - Processamento Batch

1965: a IBM lança o OS/360, um sistema operacional avançado, com compartilhamento de

Tabela 1 - Características por Fase

3. Tipos de Sistemas Operacionais

 Sistemas Multiprogramáveis/Multitarefa: usuário executa mais de uma tarefa de

3.1.1 Sistema monoprogramável/ monotarefa

3.1.2 Sistema multiprogramável/ multitarefas

A partir do numero de usuários que interagem com o sistema, podemos classificar os

Sistemas Batch Sistemas Time Sistemas Real Time

Figura 3 - Tipos de Sistemas Multiprogramáveis

Os sistemas Multiprogramáveis/Multitarefas podem ser classificados em:

Sistemas de Tempo Compartilhado (Timesharing):

Ex.: verificar os arquivos armazenados no disco.

Sistemas de Tempo (Real-time):

Tabela 2 – Comparação de Sistemas Monousuários X Multiusuários

 Vários programas podem estar residentes em memória, concorrendo pela utilização

OPERAÇÕES DE ENTRADA/SAÍDA (I/O ou E/S)

Programa Sistema Impressão

Figura 4 - Técnicas de Spooling

3.1.3 Sistemas com múltiplos processadores

Sist. Com Múltiplos

Simétricos Assimétricos Redes Distribuídos

Sistemas Fortemente Acoplados:

Assimétrico: Processador Mestre/Escravo (Master e Slave); Somente um processador Poe

Sistemas Fracamente Acoplados:

- S.O.R. (Sistema Operacional de Rede)

Cada nó é totalmente independente do outro, podendo possuir SOs diferentes.

3.2 Alguns Tipos de Sistemas Operacionais

sistema é quem decide, de forma transparente. Os sistemas operacionais distribuídos já existem há

4. Estrutura de Sistemas Operacionais

 Gerência de processos: Criação e eliminação de processos; alteração das

Figura 6 - Organização do Sistema

Gerenciamento da memória principal: Manter o controle das partes da memória

Figura 7 - Funcionalidades do Sistema Operacional

Figura 8 - Estrutura de um sistema operacional

4.3 Proteção do núcleo

4.4 Interrupções e Chamadas de Sistemas

 Notificar o processador através do barramento de controle, enviando a ele uma

Figura 9 - Roteiro típico de uma chamada de sistema

A figura a acima ilustra o funcionamento básico de uma chamada de sistema (a chamada

9. Na seqüência, a gerência de atividades devolve o controle do processador a outra

4.5 Sistemas monolíticos

Figura 10 - Sistemas Monolíticos

Em um sistema monolítico, todos os componentes do núcleo operam em modo núcleo e se

4.6 Sistemas em Camadas

Figura 11 - Sistemas em Camadas

 Não é óbvio como dividir as funcionalidades de um núcleo de sistema operacional

4.7 Sistemas Micronúcleo (Cliente-Servidor)

CLIENTE SERV.ARQ SERV.MEM SERV.REDE

Figura 12 - Sistemas Cliente-Servidor

4.8 Máquinas Virtuais

Da mesma forma, um sistema operacional só poderá executar sobre uma plataforma de

Figura 13 - Uma Maquina Virtual

 Entidade para o qual o processador está dedicado.

5.1 O PCB (Process Control Block)

Figura 14 - Bloco de Controle de Processo

5.2 Estado do Processo